[Android] Rename TabBase to Tab

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

 // Copyright 2012 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;
 
 import android.app.Activity;
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Color;
@@ skipping 22 matching lines @@
 import org.chromium.content.browser.WebContentsObserverAndroid;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.ui.base.Clipboard;
 import org.chromium.ui.base.WindowAndroid;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * The basic Java representation of a tab.  Contains and manages a {@link ContentView}.
  *
- * TabBase provides common functionality for ChromiumTestshell's Tab as well as Chrome on Android's
+ * Tab provides common functionality for ChromiumTestshell's Tab as well as Chrome on Android's
  * tab. It is intended to be extended either on Java or both Java and C++, with ownership managed
  * by this base class.
  *
  * Extending just Java:
  *  - Just extend the class normally.  Do not override initializeNative().
  * Extending Java and C++:
  *  - Because of the inner-workings of JNI, the subclass is responsible for constructing the native
- *    subclass, which in turn constructs TabAndroid (the native counterpart to TabBase), which in
- *    turn sets the native pointer for TabBase.  For destruction, subclasses in Java must clear
- *    their own native pointer reference, but TabBase#destroy() will handle deleting the native
+ *    subclass, which in turn constructs TabAndroid (the native counterpart to Tab), which in
+ *    turn sets the native pointer for Tab.  For destruction, subclasses in Java must clear
+ *    their own native pointer reference, but Tab#destroy() will handle deleting the native
  *    object.
  */
-public abstract class TabBase implements NavigationClient {
+public abstract class Tab implements NavigationClient {
     public static final int INVALID_TAB_ID = -1;
 
     /** Used for automatically generating tab ids. */
     private static final AtomicInteger sIdCounter = new AtomicInteger();
 
     private long mNativeTabAndroid;
 
     /** Unique id of this tab (within its container). */
     private final int mId;
 
     /** Whether or not this tab is an incognito tab. */
     private final boolean mIncognito;
 
     /** An Application {@link Context}.  Unlike {@link #mContext}, this is the only one that is
      * publicly exposed to help prevent leaking the {@link Activity}. */
     private final Context mApplicationContext;
 
     /** The {@link Context} used to create {@link View}s and other Android components.  Unlike
      * {@link #mApplicationContext}, this is not publicly exposed to help prevent leaking the
      * {@link Activity}. */
     private final Context mContext;
 
-    /** Gives {@link TabBase} a way to interact with the Android window. */
+    /** Gives {@link Tab} a way to interact with the Android window. */
     private final WindowAndroid mWindowAndroid;
 
     /** The current native page (e.g. chrome-native://newtab), or {@code null} if there is none. */
     private NativePage mNativePage;
 
     /** The {@link ContentView} showing the current page or {@code null} if the tab is frozen. */
     private ContentView mContentView;
 
     /** InfoBar container to show InfoBars for this tab. */
     private InfoBarContainer mInfoBarContainer;
 
     /** Manages app banners shown for this tab. */
     private AppBannerManager mAppBannerManager;
 
-    /** The sync id of the TabBase if session sync is enabled. */
+    /** The sync id of the Tab if session sync is enabled. */
     private int mSyncId;
 
     /**
      * The {@link ContentViewCore} for the current page, provided for convenience. This always
      * equals {@link ContentView#getContentViewCore()}, or {@code null} if mContentView is
      * {@code null}.
      */
     private ContentViewCore mContentViewCore;
 
     /**
-     * A list of TabBase observers.  These are used to broadcast TabBase events to listeners.
+     * A list of Tab observers.  These are used to broadcast Tab events to listeners.
      */
     private final ObserverList<TabObserver> mObservers = new ObserverList<TabObserver>();
 
     // Content layer Observers and Delegates
     private ContentViewClient mContentViewClient;
     private WebContentsObserverAndroid mWebContentsObserver;
     private VoiceSearchTabHelper mVoiceSearchTabHelper;
-    private TabBaseChromeWebContentsDelegateAndroid mWebContentsDelegate;
+    private TabChromeWebContentsDelegateAndroid mWebContentsDelegate;
 
     /**
      * A default {@link ChromeContextMenuItemDelegate} that supports some of the context menu
      * functionality.
      */
-    protected class TabBaseChromeContextMenuItemDelegate
+    protected class TabChromeContextMenuItemDelegate
             extends EmptyChromeContextMenuItemDelegate {
         private final Clipboard mClipboard;
 
         /**
-         * Builds a {@link TabBaseChromeContextMenuItemDelegate} instance.
+         * Builds a {@link TabChromeContextMenuItemDelegate} instance.
          */
-        public TabBaseChromeContextMenuItemDelegate() {
+        public TabChromeContextMenuItemDelegate() {
             mClipboard = new Clipboard(getApplicationContext());
         }
 
         @Override
         public boolean isIncognito() {
             return mIncognito;
         }
 
         @Override
         public void onSaveToClipboard(String text, boolean isUrl) {
             mClipboard.setText(text, text);
         }
 
         @Override
         public void onSaveImageToClipboard(String url) {
             mClipboard.setHTMLText("<img src=\"" + url + "\">", url, url);
         }
     }
 
     /**
      * A basic {@link ChromeWebContentsDelegateAndroid} that forwards some calls to the registered
      * {@link TabObserver}s.  Meant to be overridden by subclasses.
      */
-    public class TabBaseChromeWebContentsDelegateAndroid
+    public class TabChromeWebContentsDelegateAndroid
             extends ChromeWebContentsDelegateAndroid {
         @Override
         public void onLoadProgressChanged(int progress) {
             for (TabObserver observer : mObservers) {
-                observer.onLoadProgressChanged(TabBase.this, progress);
+                observer.onLoadProgressChanged(Tab.this, progress);
             }
         }
 
         @Override
         public void onUpdateUrl(String url) {
-            for (TabObserver observer : mObservers) observer.onUpdateUrl(TabBase.this, url);
+            for (TabObserver observer : mObservers) observer.onUpdateUrl(Tab.this, url);
         }
 
         @Override
         public void showRepostFormWarningDialog(final ContentViewCore contentViewCore) {
             RepostFormWarningDialog warningDialog = new RepostFormWarningDialog(
                     new Runnable() {
                         @Override
                         public void run() {
                             contentViewCore.cancelPendingReload();
                         }
                     }, new Runnable() {
                         @Override
                         public void run() {
                             contentViewCore.continuePendingReload();
                         }
                     });
             Activity activity = (Activity) mContext;
             warningDialog.show(activity.getFragmentManager(), null);
         }
 
         @Override
         public void toggleFullscreenModeForTab(boolean enableFullscreen) {
             for (TabObserver observer : mObservers) {
-                observer.onToggleFullscreenMode(TabBase.this, enableFullscreen);
+                observer.onToggleFullscreenMode(Tab.this, enableFullscreen);
             }
         }
 
         @Override
         public void navigationStateChanged(int flags) {
             if ((flags & INVALIDATE_TYPE_TITLE) != 0) {
-                for (TabObserver observer : mObservers) observer.onTitleUpdated(TabBase.this);
+                for (TabObserver observer : mObservers) observer.onTitleUpdated(Tab.this);
             }
             if ((flags & INVALIDATE_TYPE_URL) != 0) {
-                for (TabObserver observer : mObservers) observer.onUrlUpdated(TabBase.this);
+                for (TabObserver observer : mObservers) observer.onUrlUpdated(Tab.this);
             }
         }
     }
 
-    private class TabBaseContextMenuPopulator extends ContextMenuPopulatorWrapper {
-        public TabBaseContextMenuPopulator(ContextMenuPopulator populator) {
+    private class TabContextMenuPopulator extends ContextMenuPopulatorWrapper {
+        public TabContextMenuPopulator(ContextMenuPopulator populator) {
             super(populator);
         }
 
         @Override
         public void buildContextMenu(ContextMenu menu, Context context, ContextMenuParams params) {
             super.buildContextMenu(menu, context, params);
-            for (TabObserver observer : mObservers) observer.onContextMenuShown(TabBase.this, menu);
+            for (TabObserver observer : mObservers)
+                observer.onContextMenuShown(Tab.this, menu);

[Ted C, 2014/02/27 17:25:44]

This should go back on the previous line (braces always required in java unless
it all fits on one line)

[Bernhard Bauer, 2014/02/27 17:40:04]

Done.

         }
     }
 
-    private class TabBaseWebContentsObserverAndroid extends WebContentsObserverAndroid {
-        public TabBaseWebContentsObserverAndroid(ContentViewCore contentViewCore) {
+    private class TabWebContentsObserverAndroid extends WebContentsObserverAndroid {
+        public TabWebContentsObserverAndroid(ContentViewCore contentViewCore) {
             super(contentViewCore);
         }
 
         @Override
         public void navigationEntryCommitted() {
             if (getNativePage() != null) {
                 pushNativePageStateToNavigationEntry();
             }
         }
 
         @Override
         public void didFailLoad(boolean isProvisionalLoad, boolean isMainFrame, int errorCode,
                 String description, String failingUrl) {
             for (TabObserver observer : mObservers) {
-                observer.onDidFailLoad(TabBase.this, isProvisionalLoad, isMainFrame, errorCode,
+                observer.onDidFailLoad(Tab.this, isProvisionalLoad, isMainFrame, errorCode,
                         description, failingUrl);
             }
         }
     }
 
     /**
-     * Creates an instance of a {@link TabBase} with no id.
+     * Creates an instance of a {@link Tab} with no id.
      * @param incognito Whether or not this tab is incognito.
      * @param context   An instance of a {@link Context}.
      * @param window    An instance of a {@link WindowAndroid}.
      */
-    public TabBase(boolean incognito, Context context, WindowAndroid window) {
+    protected Tab(boolean incognito, Context context, WindowAndroid window) {

[Ted C, 2014/02/27 17:25:44]

any reason to reduce the visibility of the constructors?  I know the hope is
that this would be non-static in the future so maybe it's worth keeping them
public for now.

And to go even further...it looks like createAutoLoginProcessor is the only
method keeping this class still abstract.  Maybe we should just have that return
an empty implementation and remove the abstract for good.

[Bernhard Bauer, 2014/02/27 17:40:04]

Hm, I think that was an artifact from an older version where I was trying to do
the rename without breaking downstream temporarily (which turned out not to
work). Changed to public again. 
Sounds good; I'll do that in a follow-up CL though, to keep this one focused on
one thing.

         this(INVALID_TAB_ID, incognito, context, window);
     }
 
     /**
-     * Creates an instance of a {@link TabBase}.
+     * Creates an instance of a {@link Tab}.
      * @param id        The id this tab should be identified with.
      * @param incognito Whether or not this tab is incognito.
      * @param context   An instance of a {@link Context}.
      * @param window    An instance of a {@link WindowAndroid}.
      */
-    public TabBase(int id, boolean incognito, Context context, WindowAndroid window) {
+    protected Tab(int id, boolean incognito, Context context, WindowAndroid window) {
         // We need a valid Activity Context to build the ContentView with.
         assert context == null || context instanceof Activity;
 
         mId = generateValidId(id);
         mIncognito = incognito;
         // TODO(dtrainor): Only store application context here.
         mContext = context;
         mApplicationContext = context != null ? context.getApplicationContext() : null;
         mWindowAndroid = window;
     }
 
     /**
-     * Adds a {@link TabObserver} to be notified on {@link TabBase} changes.
+     * Adds a {@link TabObserver} to be notified on {@link Tab} changes.
      * @param observer The {@link TabObserver} to add.
      */
     public final void addObserver(TabObserver observer) {
         mObservers.addObserver(observer);
     }
 
     /**
      * Removes a {@link TabObserver}.
      * @param observer The {@link TabObserver} to remove.
      */
@@ skipping 51 matching lines @@
     }
 
     /**
      * Requests the current navigation to be loaded upon the next call to loadIfNecessary().
      */
     protected void requestRestoreLoad() {
         if (mContentViewCore != null) mContentViewCore.requestRestoreLoad();
     }
 
     /**
-     * @return Whether or not the {@link TabBase} is currently showing an interstitial page, such as
+     * @return Whether or not the {@link Tab} is currently showing an interstitial page, such as
      *         a bad HTTPS page.
      */
     public boolean isShowingInterstitialPage() {
         ContentViewCore contentViewCore = getContentViewCore();
         return contentViewCore != null && contentViewCore.isShowingInterstitialPage();
     }
 
     /**
      * @return Whether or not the tab has something valid to render.
      */
@@ skipping 145 matching lines @@
     /**
      * @return The {@link NativePage} associated with the current page, or {@code null} if there is
      *         no current page or the current page is displayed using something besides
      *         {@link NativePage}.
      */
     public NativePage getNativePage() {
         return mNativePage;
     }
 
     /**
-     * @return Whether or not the {@link TabBase} represents a {@link NativePage}.
+     * @return Whether or not the {@link Tab} represents a {@link NativePage}.
      */
     public boolean isNativePage() {
         return mNativePage != null;
     }
 
     /**
      * Set whether or not the {@link ContentViewCore} should be using a desktop user agent for the
      * currently loaded page.
      * @param useDesktop     If {@code true}, use a desktop user agent.  Otherwise use a mobile one.
      * @param reloadOnChange Reload the page if the user agent has changed.
@@ skipping 49 matching lines @@
      * @return The {@link ContentViewClient} currently bound to any {@link ContentViewCore}
      *         associated with the current page.  There can still be a {@link ContentViewClient}
      *         even when there is no {@link ContentViewCore}.
      */
     protected ContentViewClient getContentViewClient() {
         return mContentViewClient;
     }
 
     /**
      * @param client The {@link ContentViewClient} to be bound to any current or new
-     *               {@link ContentViewCore}s associated with this {@link TabBase}.
+     *               {@link ContentViewCore}s associated with this {@link Tab}.
      */
     protected void setContentViewClient(ContentViewClient client) {
         if (mContentViewClient == client) return;
 
         ContentViewClient oldClient = mContentViewClient;
         mContentViewClient = client;
 
         if (mContentViewCore == null) return;
 
         if (mContentViewClient != null) {
@@ skipping 36 matching lines @@
      */
     protected void showRenderedPage() {
         if (mNativePage == null) return;
         NativePage previousNativePage = mNativePage;
         mNativePage = null;
         for (TabObserver observer : mObservers) observer.onContentChanged(this);
         destroyNativePageInternal(previousNativePage);
     }
 
     /**
-     * Initializes this {@link TabBase}.
+     * Initializes this {@link Tab}.
      */
     public void initialize() {
         initializeNative();
     }
 
     /**
      * Builds the native counterpart to this class.  Meant to be overridden by subclasses to build
      * subclass native counterparts instead.  Subclasses should not call this via super and instead
      * rely on the native class to create the JNI association.
      */
@@ skipping 21 matching lines @@
      */
     protected void initContentView(long nativeWebContents) {
         NativePage previousNativePage = mNativePage;
         mNativePage = null;
         destroyNativePageInternal(previousNativePage);
 
         mContentView = ContentView.newInstance(mContext, nativeWebContents, getWindowAndroid());
 
         mContentViewCore = mContentView.getContentViewCore();
         mWebContentsDelegate = createWebContentsDelegate();
-        mWebContentsObserver = new TabBaseWebContentsObserverAndroid(mContentViewCore);
+        mWebContentsObserver = new TabWebContentsObserverAndroid(mContentViewCore);
         mVoiceSearchTabHelper = new VoiceSearchTabHelper(mContentViewCore);
 
         if (mContentViewClient != null) mContentViewCore.setContentViewClient(mContentViewClient);
 
         assert mNativeTabAndroid != 0;
         nativeInitWebContents(
                 mNativeTabAndroid, mIncognito, mContentViewCore, mWebContentsDelegate,
-                new TabBaseContextMenuPopulator(createContextMenuPopulator()));
+                new TabContextMenuPopulator(createContextMenuPopulator()));
 
         // In the case where restoring a Tab or showing a prerendered one we already have a
         // valid infobar container, no need to recreate one.
         if (mInfoBarContainer == null) {
             // The InfoBarContainer needs to be created after the ContentView has been natively
             // initialized.
             mInfoBarContainer = new InfoBarContainer(
                     (Activity) mContext, createAutoLoginProcessor(), getId(), getContentView(),
                     nativeWebContents);
         } else {
             mInfoBarContainer.onParentViewChanged(getId(), getContentView());
         }
 
         if (AppBannerManager.isEnabled() && mAppBannerManager == null) {
             mAppBannerManager = new AppBannerManager(this);
         }
 
         for (TabObserver observer : mObservers) observer.onContentChanged(this);
     }
 
     /**
      * Cleans up all internal state, destroying any {@link NativePage} or {@link ContentView}
-     * currently associated with this {@link TabBase}.  This also destroys the native counterpart
+     * currently associated with this {@link Tab}.  This also destroys the native counterpart
      * to this class, which means that all subclasses should erase their native pointers after
-     * this method is called.  Once this call is made this {@link TabBase} should no longer be used.
+     * this method is called.  Once this call is made this {@link Tab} should no longer be used.
      */
     public void destroy() {
         for (TabObserver observer : mObservers) observer.onDestroyed(this);
 
         NativePage currentNativePage = mNativePage;
         mNativePage = null;
         destroyNativePageInternal(currentNativePage);
         destroyContentView(true);
 
         // Destroys the native tab after destroying the ContentView but before destroying the
@@ skipping 86 matching lines @@
      * Gives subclasses the chance to clean up some state associated with this {@link ContentView}.
      * This is because {@link #getContentView()} can return {@code null} if a {@link NativePage}
      * is showing.
      * @param contentView The {@link ContentView} that should have associated state cleaned up.
      */
     protected void destroyContentViewInternal(ContentView contentView) {
     }
 
     /**
      * A helper method to allow subclasses to build their own delegate.
-     * @return An instance of a {@link TabBaseChromeWebContentsDelegateAndroid}.
+     * @return An instance of a {@link TabChromeWebContentsDelegateAndroid}.
      */
-    protected TabBaseChromeWebContentsDelegateAndroid createWebContentsDelegate() {
-        return new TabBaseChromeWebContentsDelegateAndroid();
+    protected TabChromeWebContentsDelegateAndroid createWebContentsDelegate() {
+        return new TabChromeWebContentsDelegateAndroid();
     }
 
     /**
      * A helper method to allow subclasses to build their own menu populator.
      * @return An instance of a {@link ContextMenuPopulator}.
      */
     protected ContextMenuPopulator createContextMenuPopulator() {
-        return new ChromeContextMenuPopulator(new TabBaseChromeContextMenuItemDelegate());
+        return new ChromeContextMenuPopulator(new TabChromeContextMenuItemDelegate());
     }
 
     /**
-     * @return The {@link WindowAndroid} associated with this {@link TabBase}.
+     * @return The {@link WindowAndroid} associated with this {@link Tab}.
      */
     public WindowAndroid getWindowAndroid() {
         return mWindowAndroid;
     }
 
     /**
-     * @return The current {@link TabBaseChromeWebContentsDelegateAndroid} instance.
+     * @return The current {@link TabChromeWebContentsDelegateAndroid} instance.
      */
-    protected TabBaseChromeWebContentsDelegateAndroid getChromeWebContentsDelegateAndroid() {
+    protected TabChromeWebContentsDelegateAndroid getChromeWebContentsDelegateAndroid() {
         return mWebContentsDelegate;
     }
 
     /**
      * Called when the favicon of the content this tab represents changes.
      */
     @CalledByNative
     protected void onFaviconUpdated() {
         for (TabObserver observer : mObservers) observer.onFaviconUpdated(this);
     }
 
     /**
      * Called when the navigation entry containing the historyitem changed,
      * for example because of a scroll offset or form field change.
      */
     @CalledByNative
     protected void onNavEntryChanged() {
     }
 
     /**
-     * @return The native pointer representing the native side of this {@link TabBase} object.
+     * @return The native pointer representing the native side of this {@link Tab} object.
      */
     @CalledByNative
     protected long getNativePtr() {
         return mNativeTabAndroid;
     }
 
     /** This is currently called when committing a pre-rendered page. */
     @CalledByNative
     private void swapWebContents(
             final long newWebContents, boolean didStartLoad, boolean didFinishLoad) {
@@ skipping 88 matching lines @@
             ContentViewCore contentViewCore, ChromeWebContentsDelegateAndroid delegate,
             ContextMenuPopulator contextMenuPopulator);
     private native void nativeDestroyWebContents(long nativeTabAndroid, boolean deleteNative);
     private native WebContents nativeGetWebContents(long nativeTabAndroid);
     private native Profile nativeGetProfileAndroid(long nativeTabAndroid);
     private native int nativeGetSecurityLevel(long nativeTabAndroid);
     private native void nativeSetActiveNavigationEntryTitleForUrl(long nativeTabAndroid, String url,
             String title);
     private native boolean nativePrint(long nativeTabAndroid);
 }