Rename classes related to top controls

chrome/android/java/src/org/chromium/chrome/browser/fullscreen/ChromeFullscreenManager.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.fullscreen;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.ObjectAnimator;
 import android.app.Activity;
@@ skipping 20 matching lines @@
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.library_loader.LibraryLoader;
 import org.chromium.chrome.browser.fullscreen.FullscreenHtmlApiHandler.FullscreenHtmlApiDelegate;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabModel.TabSelectionType;
 import org.chromium.chrome.browser.tabmodel.TabModelSelector;
 import org.chromium.chrome.browser.tabmodel.TabModelSelectorTabModelObserver;
 import org.chromium.chrome.browser.widget.ControlContainer;
 import org.chromium.content.browser.ContentVideoView;
 import org.chromium.content.browser.ContentViewCore;
-import org.chromium.content_public.common.TopControlsState;
+import org.chromium.content_public.common.BrowserControlsState;
 
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.HashSet;
 
 /**
  * A class that manages control and content views to create the fullscreen mode.
  */
 public class ChromeFullscreenManager
         extends FullscreenManager implements ActivityStateListener, WindowFocusChangedListener {
@@ skipping 33 matching lines @@
 
     private int mPersistentControlsCurrentToken;
     private long mCurrentShowTime;
     private int mActivityShowToken = INVALID_TOKEN;
 
     private ObjectAnimator mControlAnimation;
     private boolean mCurrentAnimationIsShowing;
 
     private boolean mDisableBrowserOverride;
 
-    private boolean mTopControlsPermanentlyHidden;
-    private boolean mTopControlsAndroidViewHidden;
+    private boolean mBrowserControlsPermanentlyHidden;
+    private boolean mBrowserControlsAndroidViewHidden;
     private final boolean mSupportsBrowserOverride;
 
     private final ArrayList<FullscreenListener> mListeners = new ArrayList<FullscreenListener>();
 
     /**
      * A listener that gets notified of changes to the fullscreen state.
      */
     public interface FullscreenListener {
         /**
          * Called whenever the content's offset changes.
@@ skipping 161 matching lines @@
         }
     }
 
     @Override
     protected FullscreenHtmlApiDelegate createApiDelegate() {
         return new FullscreenHtmlApiDelegate() {
             @Override
             public void onEnterFullscreen() {
                 Tab tab = getTab();
                 if (getControlOffset() == -mControlContainerHeight) {
-                    // The top controls are currently hidden.
+                    // The browser controls are currently hidden.
                     getHtmlApiHandler().enterFullscreen(tab);
                 } else {
-                    // We should hide top controls first.
+                    // We should hide browser controls first.
                     mIsEnteringPersistentModeState = true;
                     tab.updateFullscreenEnabledState();
                 }
             }
 
             @Override
             public boolean cancelPendingEnterFullscreen() {
                 boolean wasPending = mIsEnteringPersistentModeState;
                 mIsEnteringPersistentModeState = false;
                 return wasPending;
             }
 
             @Override
             public void onFullscreenExited(Tab tab) {
-                // At this point, top controls are hidden. Show top controls only if it's
+                // At this point, browser controls are hidden. Show browser controls only if it's
                 // permitted.
-                tab.updateTopControlsState(TopControlsState.SHOWN, true);
+                tab.updateBrowserControlsState(BrowserControlsState.SHOWN, true);
             }
 
             @Override
             public boolean shouldShowNotificationToast() {
                 return !isOverlayVideoMode();
             }
         };
     }
 
     /**
-     * Disables the ability for the browser to override the renderer provided top controls
+     * Disables the ability for the browser to override the renderer provided browser controls
      * position for testing.
      */
     @VisibleForTesting
     public void disableBrowserOverrideForTest() {
         ThreadUtils.assertOnUiThread();
 
         mDisableBrowserOverride = true;
         mPersistentControlTokens.clear();
         mHandler.removeMessages(MSG_ID_HIDE_CONTROLS);
         if (mControlAnimation != null) {
@@ skipping 41 matching lines @@
     public void hideControlsPersistent(int token) {
         if (!mSupportsBrowserOverride) return;
         if (mPersistentControlTokens.remove(token) && mPersistentControlTokens.isEmpty()) {
             update(false);
         }
     }
 
     /**
      * @param remove Whether or not to forcefully remove the toolbar.
      */
-    public void setTopControlsPermamentlyHidden(boolean remove) {
-        if (remove == mTopControlsPermanentlyHidden) return;
-        mTopControlsPermanentlyHidden = remove;
+    public void setBrowserControlsPermamentlyHidden(boolean remove) {
+        if (remove == mBrowserControlsPermanentlyHidden) return;
+        mBrowserControlsPermanentlyHidden = remove;
         updateVisuals();
     }
 
     /**
      * @return Whether or not the toolbar is forcefully being removed.
      */
-    public boolean areTopControlsPermanentlyHidden() {
-        return mTopControlsPermanentlyHidden;
+    public boolean areBrowserControlsPermanentlyHidden() {
+        return mBrowserControlsPermanentlyHidden;
     }
 
     /**
-     * @return Whether the top controls should be drawn as a texture.
+     * @return Whether the browser controls should be drawn as a texture.
      */
     public boolean drawControlsAsTexture() {
         return getControlOffset() > -mControlContainerHeight;
     }
 
     @Override
-    public int getTopControlsHeight() {
+    public int getBrowserControlsHeight() {
         return mControlContainerHeight;
     }
 
     @Override
     public float getContentOffset() {
-        if (mTopControlsPermanentlyHidden) return 0;
+        if (mBrowserControlsPermanentlyHidden) return 0;
         return rendererContentOffset();
     }
 
     /**
      * @return The offset of the controls from the top of the screen.
      */
     public float getControlOffset() {
-        if (mTopControlsPermanentlyHidden) return -getTopControlsHeight();
+        if (mBrowserControlsPermanentlyHidden) return -getBrowserControlsHeight();
         return mControlOffset;
     }
 
     /**
      * @return The toolbar control container.
      */
     public ControlContainer getControlContainer() {
         return mControlContainer;
     }
 
@@ skipping 69 matching lines @@
 
     /**
      * Updates the content view's viewport size to have it render the content correctly.
      *
      * @param viewCore The ContentViewCore to update.
      */
     public void updateContentViewViewportSize(ContentViewCore viewCore) {
         if (viewCore == null) return;
         if (mInGesture || mContentViewScrolling) return;
 
-        // Update content viewport size only when the top controls are not animating.
+        // Update content viewport size only when the browser controls are not animating.
         int contentOffset = (int) rendererContentOffset();
         if (contentOffset != 0 && contentOffset != mControlContainerHeight) return;
         viewCore.setTopControlsHeight(mControlContainerHeight, contentOffset > 0);
     }
 
     @Override
     public void updateContentViewChildrenState() {
         ContentViewCore contentViewCore = getActiveContentViewCore();
         if (contentViewCore == null) return;
         ViewGroup view = contentViewCore.getContainerView();
@@ skipping 21 matching lines @@
         float offset = getControlOffset();
         if (Float.compare(mPreviousControlOffset, offset) != 0) {
             mPreviousControlOffset = offset;
 
             scheduleVisibilityUpdate();
             if (shouldShowAndroidControls()) {
                 mControlContainer.getView().setTranslationY(getControlOffset());
             }
 
             // Whether we need the compositor to draw again to update our animation.
-            // Should be |false| when the top controls are only moved through the page scrolling.
+            // Should be |false| when the browser controls are only moved through the page
+            // scrolling.
             boolean needsAnimate = mControlAnimation != null || shouldShowAndroidControls();
             for (int i = 0; i < mListeners.size(); i++) {
                 mListeners.get(i).onVisibleContentOffsetChanged(
                         getVisibleContentOffset(), needsAnimate);
             }
         }
 
         final Tab tab = getTab();
         if (tab != null && offset == -mControlContainerHeight && mIsEnteringPersistentModeState) {
             getHtmlApiHandler().enterFullscreen(tab);
             mIsEnteringPersistentModeState = false;
         }
 
         updateContentViewChildrenState();
 
         float contentOffset = getContentOffset();
         if (Float.compare(mPreviousContentOffset, contentOffset) != 0) {
             for (int i = 0; i < mListeners.size(); i++) {
                 mListeners.get(i).onContentOffsetChanged(contentOffset);
             }
             mPreviousContentOffset = contentOffset;
         }
 
         TraceEvent.end("FullscreenManager:updateVisuals");
     }
 
     /**
-     * @param hide Whether or not to force the top controls Android view to hide.  If this is
-     *             {@code false} the top controls Android view will show/hide based on position, if
-     *             it is {@code true} the top controls Android view will always be hidden.
+     * @param hide Whether or not to force the browser controls Android view to hide.  If this is
+     *             {@code false} the browser controls Android view will show/hide based on position,
+     *             if it is {@code true} the browser controls Android view will always be hidden.
      */
-    public void setHideTopControlsAndroidView(boolean hide) {
-        if (mTopControlsAndroidViewHidden == hide) return;
-        mTopControlsAndroidViewHidden = hide;
+    public void setHideBrowserControlsAndroidView(boolean hide) {
+        if (mBrowserControlsAndroidViewHidden == hide) return;
+        mBrowserControlsAndroidViewHidden = hide;
         scheduleVisibilityUpdate();
     }
 
     private boolean shouldShowAndroidControls() {
-        if (mTopControlsAndroidViewHidden) return false;
+        if (mBrowserControlsAndroidViewHidden) return false;
 
         boolean showControls = getControlOffset() == 0;
         ContentViewCore contentViewCore = getActiveContentViewCore();
         if (contentViewCore == null) return showControls;
         ViewGroup contentView = contentViewCore.getContainerView();
 
         for (int i = 0; i < contentView.getChildCount(); i++) {
             View child = contentView.getChildAt(i);
             if (!(child.getLayoutParams() instanceof FrameLayout.LayoutParams)) continue;
 
@@ skipping 41 matching lines @@
     }
 
     private ContentViewCore getActiveContentViewCore() {
         Tab tab = getTab();
         return tab != null ? tab.getContentViewCore() : null;
     }
 
     @Override
     public void setPositionsForTabToNonFullscreen() {
         Tab tab = getTab();
-        if (tab == null || tab.isShowingTopControlsEnabled()) {
+        if (tab == null || tab.isShowingBrowserControlsEnabled()) {
             setPositionsForTab(0, mControlContainerHeight);
         } else {
             setPositionsForTab(-mControlContainerHeight, 0);
         }
     }
 
     @Override
     public void setPositionsForTab(float controlsOffset, float contentOffset) {
         // Once we get an update from a tab, clear the activity show token and allow the render
-        // to control the positions of the top controls.
+        // to control the positions of the browser controls.
         if (mActivityShowToken != INVALID_TOKEN) {
             hideControlsPersistent(mActivityShowToken);
             mActivityShowToken = INVALID_TOKEN;
         }
 
         float rendererControlOffset =
                 Math.round(Math.max(controlsOffset, -mControlContainerHeight));
         float rendererContentOffset = Math.min(
                 Math.round(contentOffset), rendererControlOffset + mControlContainerHeight);
 
         if (Float.compare(rendererControlOffset, mRendererControlOffset) == 0
                 && Float.compare(rendererContentOffset, mRendererContentOffset) == 0) {
             return;
         }
 
         mRendererControlOffset = rendererControlOffset;
         mRendererContentOffset = rendererContentOffset;
         updateControlOffset();
 
         if (mControlAnimation == null) updateVisuals();
     }
 
     /**
      * @param e The dispatched motion event
      * @return Whether or not this motion event is in the top control container area and should be
      *         consumed.
      */
     public boolean onInterceptMotionEvent(MotionEvent e) {
         return e.getY() < getControlOffset() + mControlContainerHeight
-                && !mTopControlsAndroidViewHidden;
+                && !mBrowserControlsAndroidViewHidden;
     }
 
     /**
      * Notifies the fullscreen manager that a motion event has occurred.
      * @param e The dispatched motion event.
      */
     public void onMotionEvent(MotionEvent e) {
         int eventAction = e.getActionMasked();
         if (eventAction == MotionEvent.ACTION_DOWN
                 || eventAction == MotionEvent.ACTION_POINTER_DOWN) {
@@ skipping 71 matching lines @@
         mControlAnimation.start();
         mCurrentAnimationIsShowing = show;
     }
 
     @Override
     public void onContentViewScrollingStateChanged(boolean scrolling) {
         mContentViewScrolling = scrolling;
         if (!scrolling) updateVisuals();
     }
 }