Java Code Examples for org.chromium.base.metrics.RecordHistogram#recordBooleanHistogram()

/**
 * Starts showing a context menu for {@code view} based on {@code params}.
 * @param contentViewCore The {@link ContentViewCore} to show the menu to.
 * @param params          The {@link ContextMenuParams} that indicate what menu items to show.
 */
@CalledByNative
private boolean showContextMenu(ContentViewCore contentViewCore, ContextMenuParams params) {
    final View view = contentViewCore.getContainerView();

    if (view == null
            || view.getVisibility() != View.VISIBLE
            || view.getParent() == null) {
        return false;
    }

    mCurrentContextMenuParams = params;

    view.setOnCreateContextMenuListener(this);
    if (view.showContextMenu()) {
        WebContents webContents = contentViewCore.getWebContents();
        RecordHistogram.recordBooleanHistogram(
                "ContextMenu.Shown", webContents != null);
        if (webContents != null) webContents.onContextMenuOpened();
        return true;
    }
    return false;
}
 

/**
 * Called when clearing browsing data completes.
 * Implements the ChromePreferences.OnClearBrowsingDataListener interface.
 */
@Override
public void onBrowsingDataCleared() {
    if (getActivity() == null) return;

    // If the user deleted their browsing history, the dialog about other forms of history
    // is enabled, and it has never been shown before, show it. Note that opening a new
    // DialogFragment is only possible if the Activity is visible.
    //
    // If conditions to show the dialog about other forms of history are not met, just close
    // this preference screen.
    if (MultiWindowUtils.isActivityVisible(getActivity())
            && getSelectedOptions().contains(DialogOption.CLEAR_HISTORY)
            && mIsDialogAboutOtherFormsOfBrowsingHistoryEnabled
            && !OtherFormsOfHistoryDialogFragment.wasDialogShown(getActivity())) {
        mDialogAboutOtherFormsOfBrowsingHistory = new OtherFormsOfHistoryDialogFragment();
        mDialogAboutOtherFormsOfBrowsingHistory.show(getActivity());
        dismissProgressDialog();
        RecordHistogram.recordBooleanHistogram(DIALOG_HISTOGRAM, true);
    } else {
        dismissProgressDialog();
        getActivity().finish();
        RecordHistogram.recordBooleanHistogram(DIALOG_HISTOGRAM, false);
    }
}
 

/**
 * Called when a page has finished loading.
 */
protected void didFinishPageLoad() {
    mIsBeingRestored = false;
    mIsTabStateDirty = true;
    updateTitle();
    updateFullscreenEnabledState();
    if (!isNativePage()) {
        RecordHistogram.recordBooleanHistogram(
                "Navigation.IsMobileOptimized", mContentViewCore.getIsMobileOptimizedHint());
    }

    if (mTabUma != null) mTabUma.onPageLoadFinished();

    for (TabObserver observer : mObservers) observer.onPageLoadFinished(this);

    // Handle the case where a commit or prerender swap notification failed to arrive and the
    // enable fullscreen message was never enqueued.
    scheduleEnableFullscreenLoadDelayIfNecessary();
}
 

@Override
public void onClosed(StateChangeReason reason) {
    if (mReaderModePanel == null || mTabModelSelector == null) return;

    restoreInfobars();

    // Only dismiss the panel if the close was a result of user interaction.
    if (reason != StateChangeReason.FLING && reason != StateChangeReason.SWIPE
            && reason != StateChangeReason.CLOSE_BUTTON) {
        return;
    }

    // Record close button usage.
    if (reason == StateChangeReason.CLOSE_BUTTON) {
        RecordHistogram.recordBooleanHistogram("DomDistiller.BarCloseButtonUsage",
                mReaderModePanel.getPanelState() == PanelState.EXPANDED
                || mReaderModePanel.getPanelState() == PanelState.MAXIMIZED);
    }

    int currentTabId = mTabModelSelector.getCurrentTabId();
    if (!mTabStatusMap.containsKey(currentTabId)) return;
    mTabStatusMap.get(currentTabId).setIsDismissed(true);
}
 

/**
 * Called when a top-level Chrome activity (ChromeTabbedActivity, FullscreenActivity) is
 * started in foreground. It will not be called again when other Chrome activities take over
 * (see onStart()), that is, when correct activity calls startActivity() for another Chrome
 * activity.
 */
private void onForegroundSessionStart() {
    UmaUtils.recordForegroundStartTime();
    ChildProcessLauncher.onBroughtToForeground();
    updatePasswordEchoState();
    FontSizePrefs.getInstance(mApplication).onSystemFontScaleChanged();
    updateAcceptLanguages();
    mVariationsSession.start(mApplication);
    mPowerBroadcastReceiver.onForegroundSessionStart();

    // Track the ratio of Chrome startups that are caused by notification clicks.
    // TODO(johnme): Add other reasons (and switch to recordEnumeratedHistogram).
    RecordHistogram.recordBooleanHistogram(
            "Startup.BringToForegroundReason",
            NotificationPlatformBridge.wasNotificationRecentlyClicked());
}
 

/**
 * Called when clearing browsing data completes.
 * Implements the ChromePreferences.OnClearBrowsingDataListener interface.
 */
@Override
public void onBrowsingDataCleared() {
    if (getActivity() == null) return;

    // If the user deleted their browsing history, the dialog about other forms of history
    // is enabled, and it has never been shown before, show it. Note that opening a new
    // DialogFragment is only possible if the Activity is visible.
    //
    // If conditions to show the dialog about other forms of history are not met, just close
    // this preference screen.
    if (MultiWindowUtils.isActivityVisible(getActivity())
            && getSelectedOptions().contains(DialogOption.CLEAR_HISTORY)
            && mIsDialogAboutOtherFormsOfBrowsingHistoryEnabled
            && !OtherFormsOfHistoryDialogFragment.wasDialogShown(getActivity())) {
        mDialogAboutOtherFormsOfBrowsingHistory = new OtherFormsOfHistoryDialogFragment();
        mDialogAboutOtherFormsOfBrowsingHistory.show(getActivity());
        dismissProgressDialog();
        RecordHistogram.recordBooleanHistogram(DIALOG_HISTOGRAM, true);
    } else {
        dismissProgressDialog();
        getActivity().finish();
        RecordHistogram.recordBooleanHistogram(DIALOG_HISTOGRAM, false);
    }
}
 

/**
 * Returns if we should show the important sites dialog. We check to see if
 * <ol>
 * <li>We've fetched the important sites,
 * <li>there are important sites,
 * <li>the feature is enabled, and
 * <li>we have cache or cookies selected.
 * </ol>
 */
private boolean shouldShowImportantSitesDialog() {
    if (!ChromeFeatureList.isEnabled(ChromeFeatureList.IMPORTANT_SITES_IN_CBD)) return false;
    EnumSet<DialogOption> selectedOptions = getSelectedOptions();
    if (!selectedOptions.contains(DialogOption.CLEAR_CACHE)
            && !selectedOptions.contains(DialogOption.CLEAR_COOKIES_AND_SITE_DATA)) {
        return false;
    }
    boolean haveImportantSites =
            mSortedImportantDomains != null && mSortedImportantDomains.length != 0;
    RecordHistogram.recordBooleanHistogram(
            "History.ClearBrowsingData.ImportantDialogShown", haveImportantSites);
    return haveImportantSites;
}
 

void onDestroy() {
    updateTabState(TAB_STATE_CLOSED);

    if (mTabCreationState == TabCreationState.LIVE_IN_BACKGROUND
            || mTabCreationState == TabCreationState.FROZEN_FOR_LAZY_LOAD) {
        RecordHistogram.recordBooleanHistogram(
                "Tab.BackgroundTabShown", mLastShownTimestamp != -1);
    }

    recordNumBackgroundTabsOpened();
}
 

/**
 * Transfers a prerendered WebContents if one exists.
 *
 * This resets the internal WebContents; a subsequent call to this method
 * returns null. Must be called from the UI thread.
 * If a prerender exists for a different URL with the same sessionId or with
 * a different referrer, then this is treated as a mispredict from the
 * client application, and cancels the previous prerender. This is done to
 * avoid keeping resources laying around for too long, but is subject to a
 * race condition, as the following scenario is possible:
 * The application calls:
 * 1. mayLaunchUrl(url1) <- IPC
 * 2. loadUrl(url2) <- Intent
 * 3. mayLaunchUrl(url3) <- IPC
 * If the IPC for url3 arrives before the intent for url2, then this methods
 * cancels the prerender for url3, which is unexpected. On the other
 * hand, not cancelling the previous prerender leads to wasted resources, as
 * a WebContents is lingering. This can be solved by requiring applications
 * to call mayLaunchUrl(null) to cancel a current prerender before 2, that
 * is for a mispredict.
 *
 * Note that this methods accepts URLs that don't exactly match the initially
 * prerendered URL. More precisely, the #fragment is ignored. In this case,
 * the client needs to navigate to the correct URL after the WebContents
 * swap. This can be tested using {@link UrlUtilities#urlsFragmentsDiffer()}.
 *
 * @param session The Binder object identifying a session.
 * @param url The URL the WebContents is for.
 * @param referrer The referrer to use for |url|.
 * @return The prerendered WebContents, or null.
 */
WebContents takePrerenderedUrl(CustomTabsSessionToken session, String url, String referrer) {
    ThreadUtils.assertOnUiThread();
    if (mSpeculation == null || session == null || !session.equals(mSpeculation.session)) {
        return null;
    }

    if (mSpeculation.speculationMode == SpeculationParams.PREFETCH) {
        cancelSpeculation(session);
        return null;
    }

    WebContents webContents = mSpeculation.webContents;
    String prerenderedUrl = mSpeculation.url;
    String prerenderReferrer = mSpeculation.referrer;
    if (referrer == null) referrer = "";
    boolean ignoreFragments = mClientManager.getIgnoreFragmentsForSession(session);
    boolean urlsMatch = TextUtils.equals(prerenderedUrl, url)
            || (ignoreFragments
                    && UrlUtilities.urlsMatchIgnoringFragments(prerenderedUrl, url));
    WebContents result = null;
    if (urlsMatch && TextUtils.equals(prerenderReferrer, referrer)) {
        result = webContents;
        mSpeculation = null;
    } else {
        cancelSpeculation(session);
    }
    if (!mClientManager.usesDefaultSessionParameters(session) && webContents != null) {
        RecordHistogram.recordBooleanHistogram(
                "CustomTabs.NonDefaultSessionPrerenderMatched", result != null);
    }

    return result;
}
 

/**
 * Records UMA data when the Offline Pages Background Load service awakens.
 * @param context android context
 */
public static void recordWakeupUMA(Context context, long taskScheduledTimeMillis) {
    DeviceConditions deviceConditions = DeviceConditions.getCurrentConditions(context);
    if (deviceConditions == null) return;

    // Report charging state.
    RecordHistogram.recordBooleanHistogram(
            "OfflinePages.Wakeup.ConnectedToPower", deviceConditions.isPowerConnected());

    // Report battery percentage.
    RecordHistogram.recordPercentageHistogram(
            "OfflinePages.Wakeup.BatteryPercentage", deviceConditions.getBatteryPercentage());

    // Report the default network found (or none, if we aren't connected).
    int connectionType = deviceConditions.getNetConnectionType();
    Log.d(TAG, "Found default network of type " + connectionType);
    RecordHistogram.recordEnumeratedHistogram("OfflinePages.Wakeup.NetworkAvailable",
            connectionType, ConnectionType.CONNECTION_LAST + 1);

    // Collect UMA on the time since the request started.
    long nowMillis = System.currentTimeMillis();
    long delayInMilliseconds = nowMillis - taskScheduledTimeMillis;
    if (delayInMilliseconds <= 0) {
        return;
    }
    RecordHistogram.recordLongTimesHistogram(
            "OfflinePages.Wakeup.DelayTime",
            delayInMilliseconds,
            TimeUnit.MILLISECONDS);
}
 

/**
 * Record if the remotely played media element is alive when the
 * {@link ExpandedControllerActivity} is shown.
 *
 * @param isMediaElementAlive if the media element is alive.
 */
public static void recordFullscreenControlsShown(boolean isMediaElementAlive) {
    if (LibraryLoader.isInitialized()) {
        RecordHistogram.recordBooleanHistogram(
                "Cast.Sender.MediaElementPresentWhenShowFullscreenControls",
                isMediaElementAlive);
    }
}
 

/**
 * Returns if we should show the important sites dialog. We check to see if
 * <ol>
 * <li>We've fetched the important sites,
 * <li>there are important sites,
 * <li>the feature is enabled, and
 * <li>we have cache or cookies selected.
 * </ol>
 */
private boolean shouldShowImportantSitesDialog() {
    if (!ChromeFeatureList.isEnabled(ChromeFeatureList.IMPORTANT_SITES_IN_CBD)) return false;
    EnumSet<DialogOption> selectedOptions = getSelectedOptions();
    if (!selectedOptions.contains(DialogOption.CLEAR_CACHE)
            && !selectedOptions.contains(DialogOption.CLEAR_COOKIES_AND_SITE_DATA)) {
        return false;
    }
    boolean haveImportantSites =
            mSortedImportantDomains != null && mSortedImportantDomains.length != 0;
    RecordHistogram.recordBooleanHistogram(
            "History.ClearBrowsingData.ImportantDialogShown", haveImportantSites);
    return haveImportantSites;
}
 

/**
 * Called when a page has finished loading.
 */
protected void didFinishPageLoad() {
    mIsBeingRestored = false;
    mIsTabStateDirty = true;
    updateTitle();
    updateFullscreenEnabledState();
    if (!isNativePage()) {
        RecordHistogram.recordBooleanHistogram(
                "Navigation.IsMobileOptimized", mContentViewCore.getIsMobileOptimizedHint());
    }

    if (mTabUma != null) mTabUma.onPageLoadFinished();

    for (TabObserver observer : mObservers) observer.onPageLoadFinished(this);
}
 

/**
 * Logs whether a quick action was clicked.
 * @param wasClicked Whether the quick action was clicked
 * @param quickActionCategory The {@link QuickActionCategory} for the quick action.
 */
public static void logQuickActionClicked(boolean wasClicked, int quickActionCategory) {
    RecordHistogram.recordBooleanHistogram(
            "Search.ContextualSearchQuickActions.Clicked."
                    + getLabelForQuickActionCategory(quickActionCategory),
             wasClicked);
}
 

/**
 * Records UMA data when the Offline Pages Background Load service awakens.
 * @param context android context
 */
public static void recordWakeupUMA(Context context, long taskScheduledTimeMillis) {
    DeviceConditions deviceConditions = getDeviceConditions(context);
    if (deviceConditions == null) return;

    // Report charging state.
    RecordHistogram.recordBooleanHistogram(
            "OfflinePages.Wakeup.ConnectedToPower", deviceConditions.isPowerConnected());

    // Report battery percentage.
    RecordHistogram.recordPercentageHistogram(
            "OfflinePages.Wakeup.BatteryPercentage", deviceConditions.getBatteryPercentage());

    // Report the default network found (or none, if we aren't connected).
    int connectionType = deviceConditions.getNetConnectionType();
    Log.d(TAG, "Found default network of type " + connectionType);
    RecordHistogram.recordEnumeratedHistogram("OfflinePages.Wakeup.NetworkAvailable",
            connectionType, ConnectionType.CONNECTION_LAST + 1);

    // Collect UMA on the time since the request started.
    long nowMillis = System.currentTimeMillis();
    long delayInMilliseconds = nowMillis - taskScheduledTimeMillis;
    if (delayInMilliseconds <= 0) {
        return;
    }
    RecordHistogram.recordLongTimesHistogram(
            "OfflinePages.Wakeup.DelayTime",
            delayInMilliseconds,
            TimeUnit.MILLISECONDS);
}
 

/**
 * Records specific histograms related to the different steps of a successful checkout.
 */
private void recordSuccessFunnelHistograms(String funnelPart) {
    RecordHistogram.recordBooleanHistogram("PaymentRequest.CheckoutFunnel." + funnelPart, true);

    if (funnelPart.equals("Completed")) {
        mJourneyLogger.recordJourneyStatsHistograms("Completed");
    }
}
 

@Override
protected void onPostExecute(Drawable image) {
    RecordHistogram.recordBooleanHistogram(
            "NewTabPage.Interests.ImageDownloadSuccess", image != null);
    mPromise.fulfill(image);
}
 

private void triggerShare(
        final Tab currentTab, final boolean shareDirectly, boolean isIncognito) {
    final Activity mainActivity = this;
    WebContents webContents = currentTab.getWebContents();

    RecordHistogram.recordBooleanHistogram(
            "OfflinePages.SharedPageWasOffline", currentTab.isOfflinePage());
    boolean canShareOfflinePage = OfflinePageBridge.isPageSharingEnabled();

    // Share an empty blockingUri in place of screenshot file. The file ready notification is
    // sent by onScreenshotReady call below when the file is written.
    final Uri blockingUri = (isIncognito || webContents == null)
            ? null
            : ChromeFileProvider.generateUriAndBlockAccess(mainActivity);
    if (canShareOfflinePage) {
        OfflinePageUtils.shareOfflinePage(shareDirectly, true, mainActivity, null,
                blockingUri, null, currentTab);
    } else {
        ShareHelper.share(shareDirectly, true, mainActivity, currentTab.getTitle(), null,
                currentTab.getUrl(), null, blockingUri, null);
        if (shareDirectly) {
            RecordUserAction.record("MobileMenuDirectShare");
        } else {
            RecordUserAction.record("MobileMenuShare");
        }
    }

    if (blockingUri == null) return;

    // Start screenshot capture and notify the provider when it is ready.
    ContentBitmapCallback callback = new ContentBitmapCallback() {
        @Override
        public void onFinishGetBitmap(Bitmap bitmap, int response) {
            ShareHelper.saveScreenshotToDisk(bitmap, mainActivity,
                    new Callback<Uri>() {
                        @Override
                        public void onResult(Uri result) {
                            // Unblock the file once it is saved to disk.
                            ChromeFileProvider.notifyFileReady(blockingUri, result);
                        }
                    });
        }
    };
    if (!mScreenshotCaptureSkippedForTesting) {
        webContents.getContentBitmapAsync(Bitmap.Config.ARGB_8888, 1.f, EMPTY_RECT, callback);
    } else {
        callback.onFinishGetBitmap(null, ReadbackResponse.SURFACE_UNAVAILABLE);
    }
}
 

@Override
public void initializeState() {
    // This method goes through 3 steps:
    // 1. Load the saved tab state (but don't start restoring the tabs yet).
    // 2. Process the Intent that this activity received and if that should result in any
    //    new tabs, create them.  This is done after step 1 so that the new tab gets
    //    created after previous tab state was restored.
    // 3. If no tabs were created in any of the above steps, create an NTP, otherwise
    //    start asynchronous tab restore (loading the previously active tab synchronously
    //    if no new tabs created in step 2).

    // Only look at the original intent if this is not a "restoration" and we are allowed to
    // process intents. Any subsequent intents are carried through onNewIntent.
    try {
        TraceEvent.begin("ChromeTabbedActivity.initializeState");

        super.initializeState();

        Intent intent = getIntent();

        boolean hadCipherData =
                CipherFactory.getInstance().restoreFromBundle(getSavedInstanceState());

        boolean noRestoreState =
                CommandLine.getInstance().hasSwitch(ChromeSwitches.NO_RESTORE_STATE);
        if (noRestoreState) {
            // Clear the state files because they are inconsistent and useless from now on.
            mTabModelSelectorImpl.clearState();
        } else if (!mIsOnFirstRun) {
            // State should be clear when we start first run and hence we do not need to load
            // a previous state. This may change the current Model, watch out for initialization
            // based on the model.
            // Never attempt to restore incognito tabs when this activity was previously swiped
            // away in Recents. http://crbug.com/626629
            boolean ignoreIncognitoFiles = !hadCipherData;
            mTabModelSelectorImpl.loadState(ignoreIncognitoFiles);
        }

        mIntentWithEffect = false;
        if ((mIsOnFirstRun || getSavedInstanceState() == null) && intent != null) {
            if (mVrShellDelegate.isVrIntent(intent)) {
                // TODO(mthiesse): Improve startup when started from a VR intent. Right now
                // we launch out of VR, partially load out of VR, then switch into VR.
                mVrShellDelegate.enterVRIfNecessary();
            } else if (!mIntentHandler.shouldIgnoreIntent(ChromeTabbedActivity.this, intent)) {
                mIntentWithEffect = mIntentHandler.onNewIntent(ChromeTabbedActivity.this,
                        intent);
            }
        }

        mCreatedTabOnStartup = getCurrentTabModel().getCount() > 0
                || mTabModelSelectorImpl.getRestoredTabCount() > 0
                || mIntentWithEffect;

        // We always need to try to restore tabs. The set of tabs might be empty, but at least
        // it will trigger the notification that tab restore is complete which is needed by
        // other parts of Chrome such as sync.
        boolean activeTabBeingRestored = !mIntentWithEffect;
        mTabModelSelectorImpl.restoreTabs(activeTabBeingRestored);

        // Only create an initial tab if no tabs were restored and no intent was handled.
        // Also, check whether the active tab was supposed to be restored and that the total
        // tab count is now non zero.  If this is not the case, tab restore failed and we need
        // to create a new tab as well.
        if (!mCreatedTabOnStartup
                || (activeTabBeingRestored && getTabModelSelector().getTotalTabCount() == 0)) {
            // If homepage URI is not determined, due to PartnerBrowserCustomizations provider
            // async reading, then create a tab at the async reading finished. If it takes
            // too long, just create NTP.
            PartnerBrowserCustomizations.setOnInitializeAsyncFinished(
                    new Runnable() {
                        @Override
                        public void run() {
                            createInitialTab();
                        }
                    }, INITIAL_TAB_CREATION_TIMEOUT_MS);
        }

        RecordHistogram.recordBooleanHistogram(
                "MobileStartup.ColdStartupIntent", mIntentWithEffect);
    } finally {
        TraceEvent.end("ChromeTabbedActivity.initializeState");
    }
}
 

/**
 * Logs whether Contextual Cards data was shown. Should be logged on tap if Contextual
 * Cards integration is enabled.
 * @param shown Whether Contextual Cards data was shown in the Bar.
 */
public static void logContextualCardsDataShown(boolean shown) {
    RecordHistogram.recordBooleanHistogram(
            "Search.ContextualSearchContextualCardsIntegration.DataShown", shown);
}