[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);
         }
     }
 
-    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) {
+    public Tab(boolean incognito, Context context, WindowAndroid window) {
         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) {
+    public 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);
 }