Rename classes related to top controls

chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.tab;
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.Application;
 import android.content.Context;
@@ skipping 80 matching lines @@
 import org.chromium.components.navigation_interception.InterceptNavigationDelegate;
 import org.chromium.components.security_state.ConnectionSecurityLevel;
 import org.chromium.content.browser.ChildProcessLauncher;
 import org.chromium.content.browser.ContentView;
 import org.chromium.content.browser.ContentViewClient;
 import org.chromium.content.browser.ContentViewCore;
 import org.chromium.content.browser.crypto.CipherFactory;
 import org.chromium.content_public.browser.GestureStateListener;
 import org.chromium.content_public.browser.LoadUrlParams;
 import org.chromium.content_public.browser.WebContents;
+import org.chromium.content_public.common.BrowserControlsState;
 import org.chromium.content_public.common.Referrer;
 import org.chromium.content_public.common.ResourceRequestBody;
-import org.chromium.content_public.common.TopControlsState;
 import org.chromium.printing.PrintManagerDelegateImpl;
 import org.chromium.printing.PrintingController;
 import org.chromium.printing.PrintingControllerImpl;
 import org.chromium.ui.base.LocalizationUtils;
 import org.chromium.ui.base.PageTransition;
 import org.chromium.ui.base.ViewAndroidDelegate;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.mojom.WindowOpenDisposition;
 
 import java.lang.ref.WeakReference;
@@ skipping 226 matching lines @@
      * didCommitProvisionalLoadForFrame(). However, we mustn't show a new native page (page B) in
      * loadUrl() if the current native page hasn't yet been committed. Otherwise, we'll show each
      * page twice (A, B, A, B): the first two times in loadUrl(), the second two times in
      * didCommitProvisionalLoadForFrame().
      */
     private boolean mIsNativePageCommitPending;
 
     private TabRedirectHandler mTabRedirectHandler;
 
     private FullscreenManager mFullscreenManager;
-    private float mPreviousFullscreenTopControlsOffsetY = Float.NaN;
+    private float mPreviousFullscreenBrowserControlsOffsetY = Float.NaN;
     private float mPreviousFullscreenContentOffsetY = Float.NaN;
     private int mFullscreenHungRendererToken = FullscreenManager.INVALID_TOKEN;
     private boolean mIsFullscreenWaitingForLoad = false;
 
     /**
      * Indicates whether this tab has been detached from its activity and the corresponding
      * {@link WindowAndroid} for reparenting to a new activity.
      */
     private boolean mIsDetachedForReparenting;
 
@@ skipping 183 matching lines @@
 
             if (didFinishLoad) {
                 // Simulate the PAGE_LOAD_FINISHED notification that we did not get.
                 didFinishPageLoad();
             }
         }
     };
 
     private TabDelegateFactory mDelegateFactory;
 
-    private TopControlsVisibilityDelegate mTopControlsVisibilityDelegate;
+    private BrowserControlsVisibilityDelegate mBrowserControlsVisibilityDelegate;
 
     /**
      * Creates an instance of a {@link Tab}.
      *
      * This constructor may be called before the native library has been loaded, so any additions
      * must be vetted for library calls.
      *
      * @param id        The id this tab should be identified with.
      * @param incognito Whether or not this tab is incognito.
      * @param window    An instance of a {@link WindowAndroid}.
@@ skipping 879 matching lines @@
     public final void initialize(WebContents webContents, TabContentManager tabContentManager,
             TabDelegateFactory delegateFactory, boolean initiallyHidden, boolean unfreeze) {
         try {
             TraceEvent.begin("Tab.initialize");
 
             mDelegateFactory = delegateFactory;
             initializeNative();
 
             RevenueStats.getInstance().tabCreated(this);
 
-            mTopControlsVisibilityDelegate =
-                    mDelegateFactory.createTopControlsVisibilityDelegate(this);
+            mBrowserControlsVisibilityDelegate =
+                    mDelegateFactory.createBrowserControlsVisibilityDelegate(this);
 
             mBlimp = BlimpClientContextFactory
                              .getBlimpClientContextForProfile(
                                      Profile.getLastUsedProfile().getOriginalProfile())
                              .isBlimpEnabled()
                     && !mIncognito;
 
             // Attach the TabContentManager if we have one.  This will bind this Tab's content layer
             // to this manager.
             // TODO(dtrainor): Remove this and move to a pull model instead of pushing the layer.
@@ skipping 121 matching lines @@
         // Update for the controllers that need the Compositor from the new Activity.
         attachTabContentManager(activity.getTabContentManager());
         mFullscreenManager = activity.getFullscreenManager();
         activity.getCompositorViewHolder().prepareForTabReparenting();
 
         // Update the delegate factory, then recreate and propagate all delegates.
         mDelegateFactory = tabDelegateFactory;
         mWebContentsDelegate = mDelegateFactory.createWebContentsDelegate(this);
         nativeUpdateDelegates(mNativeTabAndroid,
                 mWebContentsDelegate, mDelegateFactory.createContextMenuPopulator(this));
-        mTopControlsVisibilityDelegate = mDelegateFactory.createTopControlsVisibilityDelegate(this);
+        mBrowserControlsVisibilityDelegate =
+                mDelegateFactory.createBrowserControlsVisibilityDelegate(this);
         setInterceptNavigationDelegate(mDelegateFactory.createInterceptNavigationDelegate(this));
         getAppBannerManager().setIsEnabledForTab(mDelegateFactory.canShowAppBanners(this));
 
         reparentingParams.finalizeTabReparenting();
         mIsDetachedForReparenting = false;
 
         // Reload the NativePage (if any), since the old NativePage has a reference to the old
         // activity.
         maybeShowNativePage(getUrl(), true);
 
@@ skipping 413 matching lines @@
         // expects all infobars to be cleaned up before its own destruction.
         assert mNativeTabAndroid != 0;
         nativeDestroy(mNativeTabAndroid);
         assert mNativeTabAndroid == 0;
 
         if (mInfoBarContainer != null) {
             mInfoBarContainer.destroy();
             mInfoBarContainer = null;
         }
 
-        mPreviousFullscreenTopControlsOffsetY = Float.NaN;
+        mPreviousFullscreenBrowserControlsOffsetY = Float.NaN;
         mPreviousFullscreenContentOffsetY = Float.NaN;
 
         mNeedsReload = false;
 
         // Remove pending handler actions to prevent memory leaks.
         mHandler.removeCallbacksAndMessages(null);
     }
 
     /**
      * @return Whether or not this Tab has a live native component.  This will be true prior to
@@ skipping 627 matching lines @@
         if (mFullscreenManager == null) return;
 
         mFullscreenManager.hideControlsPersistent(mFullscreenHungRendererToken);
         mFullscreenHungRendererToken = FullscreenManager.INVALID_TOKEN;
         updateFullscreenEnabledState();
     }
 
     /**
      * Called when offset values related with fullscreen functionality has been changed by the
      * compositor.
-     * @param topControlsOffsetY The Y offset of the top controls in physical pixels.
+     * @param browserControlsOffsetY The Y offset of the browser controls in physical pixels.
      * @param contentOffsetY The Y offset of the content in physical pixels.
      * @param isNonFullscreenPage Whether a current page is non-fullscreen page or not.
      */
-    private void onOffsetsChanged(float topControlsOffsetY, float contentOffsetY,
-            boolean isNonFullscreenPage) {
-        mPreviousFullscreenTopControlsOffsetY = topControlsOffsetY;
+    private void onOffsetsChanged(
+            float browserControlsOffsetY, float contentOffsetY, boolean isNonFullscreenPage) {
+        mPreviousFullscreenBrowserControlsOffsetY = browserControlsOffsetY;
         mPreviousFullscreenContentOffsetY = contentOffsetY;
 
         if (mFullscreenManager == null) return;
         if (isNonFullscreenPage || isNativePage()) {
             mFullscreenManager.setPositionsForTabToNonFullscreen();
         } else {
-            mFullscreenManager.setPositionsForTab(topControlsOffsetY, contentOffsetY);
+            mFullscreenManager.setPositionsForTab(browserControlsOffsetY, contentOffsetY);
         }
         TabModelImpl.setActualTabSwitchLatencyMetricRequired();
     }
 
     /**
-     * Push state about whether or not the top controls can show or hide to the renderer.
+     * Push state about whether or not the browser controls can show or hide to the renderer.
      */
     public void updateFullscreenEnabledState() {
         if (isFrozen()) return;
 
-        updateTopControlsState(getTopControlsStateConstraints(), TopControlsState.BOTH, true);
+        updateBrowserControlsState(
+                getBrowserControlsStateConstraints(), BrowserControlsState.BOTH, true);
 
         if (getContentViewCore() != null && mFullscreenManager != null) {
             getContentViewCore().updateMultiTouchZoomSupport(
                     !mFullscreenManager.getPersistentFullscreenMode());
         }
     }
 
     /**
-     * Updates the top controls state for this tab.  As these values are set at the renderer
+     * Updates the browser controls state for this tab.  As these values are set at the renderer
      * level, there is potential for this impacting other tabs that might share the same
      * process.
      *
      * @param constraints The constraints that determine whether the controls can be shown
      *                    or hidden at all.
      * @param current The desired current state for the controls.  Pass
-     *                {@link TopControlsState#BOTH} to preserve the current position.
+     *                {@link BrowserControlsState#BOTH} to preserve the current position.
      * @param animate Whether the controls should animate to the specified ending condition or
      *                should jump immediately.
      */
-    protected void updateTopControlsState(int constraints, int current, boolean animate) {
+    protected void updateBrowserControlsState(int constraints, int current, boolean animate) {
         if (mNativeTabAndroid == 0) return;
-        nativeUpdateTopControlsState(mNativeTabAndroid, constraints, current, animate);
+        nativeUpdateBrowserControlsState(mNativeTabAndroid, constraints, current, animate);
     }
 
     /**
-     * Updates the top controls state for this tab.  As these values are set at the renderer
+     * Updates the browser controls state for this tab.  As these values are set at the renderer
      * level, there is potential for this impacting other tabs that might share the same
      * process.
      *
      * @param current The desired current state for the controls.  Pass
-     *                {@link TopControlsState#BOTH} to preserve the current position.
+     *                {@link BrowserControlsState#BOTH} to preserve the current position.
      * @param animate Whether the controls should animate to the specified ending condition or
      *                should jump immediately.
      */
-    public void updateTopControlsState(int current, boolean animate) {
-        int constraints = getTopControlsStateConstraints();
+    public void updateBrowserControlsState(int current, boolean animate) {
+        int constraints = getBrowserControlsStateConstraints();
         // Do nothing if current and constraints conflict to avoid error in
         // renderer.
-        if ((constraints == TopControlsState.HIDDEN && current == TopControlsState.SHOWN)
-                || (constraints == TopControlsState.SHOWN && current == TopControlsState.HIDDEN)) {
+        if ((constraints == BrowserControlsState.HIDDEN && current == BrowserControlsState.SHOWN)
+                || (constraints == BrowserControlsState.SHOWN
+                           && current == BrowserControlsState.HIDDEN)) {
             return;
         }
-        updateTopControlsState(getTopControlsStateConstraints(), current, animate);
+        updateBrowserControlsState(getBrowserControlsStateConstraints(), current, animate);
     }
 
     /**
-     * @return Whether hiding top controls is enabled or not.
+     * @return Whether hiding browser controls is enabled or not.
      */
-    private boolean isHidingTopControlsEnabled() {
-        return mTopControlsVisibilityDelegate.isHidingTopControlsEnabled();
+    private boolean isHidingBrowserControlsEnabled() {
+        return mBrowserControlsVisibilityDelegate.isHidingBrowserControlsEnabled();
     }
 
     /**
      * Performs any subclass-specific tasks when the Tab crashes.
      */
     void handleTabCrash() {
         mIsLoading = false;
         mIsBeingRestored = false;
 
         if (mTabUma != null) mTabUma.onRendererCrashed();
     }
 
     /**
-     * @return Whether showing top controls is enabled or not.
+     * @return Whether showing browser controls is enabled or not.
      */
-    public boolean isShowingTopControlsEnabled() {
-        return mTopControlsVisibilityDelegate.isShowingTopControlsEnabled();
+    public boolean isShowingBrowserControlsEnabled() {
+        return mBrowserControlsVisibilityDelegate.isShowingBrowserControlsEnabled();
     }
 
     /**
-     * @return The current visibility constraints for the display of top controls.
-     *         {@link TopControlsState} defines the valid return options.
+     * @return The current visibility constraints for the display of browser controls.
+     *         {@link BrowserControlsState} defines the valid return options.
      */
-    public int getTopControlsStateConstraints() {
-        boolean enableHidingTopControls = isHidingTopControlsEnabled();
-        boolean enableShowingTopControls = isShowingTopControlsEnabled();
+    public int getBrowserControlsStateConstraints() {
+        boolean enableHidingBrowserControls = isHidingBrowserControlsEnabled();
+        boolean enableShowingBrowserControls = isShowingBrowserControlsEnabled();
 
-        int constraints = TopControlsState.BOTH;
-        if (!enableShowingTopControls) {
-            constraints = TopControlsState.HIDDEN;
-        } else if (!enableHidingTopControls) {
-            constraints = TopControlsState.SHOWN;
+        int constraints = BrowserControlsState.BOTH;
+        if (!enableShowingBrowserControls) {
+            constraints = BrowserControlsState.HIDDEN;
+        } else if (!enableHidingBrowserControls) {
+            constraints = BrowserControlsState.SHOWN;
         }
         return constraints;
     }
 
     /**
      * @param manager The fullscreen manager that should be notified of changes to this tab (if
      *                set to null, no more updates will come from this tab).
      */
     public void setFullscreenManager(FullscreenManager manager) {
         mFullscreenManager = manager;
         if (mFullscreenManager != null) {
-            if (Float.isNaN(mPreviousFullscreenTopControlsOffsetY)
+            if (Float.isNaN(mPreviousFullscreenBrowserControlsOffsetY)
                     || Float.isNaN(mPreviousFullscreenContentOffsetY)) {
                 mFullscreenManager.setPositionsForTabToNonFullscreen();
             } else {
-                mFullscreenManager.setPositionsForTab(
-                        mPreviousFullscreenTopControlsOffsetY, mPreviousFullscreenContentOffsetY);
+                mFullscreenManager.setPositionsForTab(mPreviousFullscreenBrowserControlsOffsetY,
+                        mPreviousFullscreenContentOffsetY);
             }
             mFullscreenManager.showControlsTransient();
             updateFullscreenEnabledState();
         }
 
-        // For blimp mode, offset the blimp view by the height of top controls. This will ensure
+        // For blimp mode, offset the blimp view by the height of browser controls. This will ensure
         // that the view doesn't get clipped at the bottom of the page and also the touch offsets
         // would work correctly.
         if (getBlimpContents() != null && mFullscreenManager != null) {
             ViewGroup blimpView = getBlimpContents().getView();
             FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) blimpView.getLayoutParams();
             if (lp == null) {
                 lp = new FrameLayout.LayoutParams(
                         LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
             }
 
-            lp.topMargin = mFullscreenManager.getTopControlsHeight();
+            lp.topMargin = mFullscreenManager.getBrowserControlsHeight();
             blimpView.setLayoutParams(lp);
         }
     }
 
     /**
      * Add a new navigation entry for the current URL and page title.
      */
     void pushNativePageStateToNavigationEntry() {
         assert mNativeTabAndroid != 0 && getNativePage() != null;
         nativeSetActiveNavigationEntryTitleForUrl(mNativeTabAndroid, getNativePage().getUrl(),
@@ skipping 408 matching lines @@
     private native Profile nativeGetProfileAndroid(long nativeTabAndroid);
     private native int nativeLoadUrl(long nativeTabAndroid, String url, String extraHeaders,
             ResourceRequestBody postData, int transition, String referrerUrl, int referrerPolicy,
             boolean isRendererInitiated, boolean shoulReplaceCurrentEntry,
             long intentReceivedTimestamp, boolean hasUserGesture);
     private native void nativeSetActiveNavigationEntryTitleForUrl(long nativeTabAndroid, String url,
             String title);
     private native boolean nativePrint(long nativeTabAndroid);
     private native Bitmap nativeGetFavicon(long nativeTabAndroid);
     private native void nativeCreateHistoricalTab(long nativeTabAndroid);
-    private native void nativeUpdateTopControlsState(
+    private native void nativeUpdateBrowserControlsState(
             long nativeTabAndroid, int constraints, int current, boolean animate);
     private native void nativeLoadOriginalImage(long nativeTabAndroid);
     private native long nativeGetBookmarkId(long nativeTabAndroid, boolean onlyEditable);
     private native boolean nativeIsOfflinePage(long nativeTabAndroid);
     private native OfflinePageItem nativeGetOfflinePage(long nativeTabAndroid);
     private native void nativeSetInterceptNavigationDelegate(long nativeTabAndroid,
             InterceptNavigationDelegate delegate);
     private native void nativeAttachToTabContentManager(long nativeTabAndroid,
             TabContentManager tabContentManager);
     private native boolean nativeHasPrerenderedUrl(long nativeTabAndroid, String url);
 }