Remove mActivity from Tab and look at windowAndroid for tab

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.TargetApi;
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.content.Context;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Color;
 import android.graphics.Rect;
 import android.media.AudioManager;
 import android.os.Build;
 import android.os.Handler;
 import android.os.Message;
 import android.provider.Browser;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.Pair;
 import android.view.ContextMenu;
+import android.view.ContextThemeWrapper;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.widget.FrameLayout;
 
 import org.chromium.base.ActivityState;
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ApplicationState;
@@ skipping 121 matching lines @@
 
     /**
      * The required page load percentage for the page to be considered ready assuming the
      * TextureView is also ready.
      */
     private static final int CONSIDERED_READY_LOAD_PERCENTAGE = 100;
 
     /** Used for logging. */
     private static final String TAG = "Tab";
 
-    /**
-     * The {@link Activity} 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}.
-     */
-    protected final ChromeActivity mActivity;
-
     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 #mActivity}, this is the only one that is
      * publicly exposed to help prevent leaking the {@link Activity}.
      */
     private final Context mApplicationContext;
 
+    private final ContextThemeWrapper mThemedContext;
+
     /** Gives {@link Tab} a way to interact with the Android window. */
     private final WindowAndroid mWindowAndroid;
 
     /** Whether or not this {@link Tab} is initialized and should be interacted with. */
     private boolean mIsInitialized;
 
     /** The current native page (e.g. chrome-native://newtab), or {@code null} if there is none. */
     private NativePage mNativePage;
 
     /** InfoBar container to show InfoBars for this tab. */
@@ skipping 184 matching lines @@
      */
     protected boolean mLastPageLoadHasSpdyProxyPassthroughHeaders;
 
     private ChromeDownloadDelegate mDownloadDelegate;
 
     protected Handler mHandler;
 
     private final Runnable mCloseContentsRunnable = new Runnable() {
         @Override
         public void run() {
-            boolean isSelected = mActivity.getTabModelSelector().getCurrentTab() == Tab.this;
-            mActivity.getTabModelSelector().closeTab(Tab.this);
+            TabModelSelector selector = getTabModelSelector();
+            if (selector == null) return;
+            boolean isSelected = selector.getCurrentTab() == Tab.this;
+            selector.closeTab(Tab.this);
 
             // If the parent Tab belongs to another Activity, fire the Intent to bring it back.
             if (isSelected && getParentIntent() != null
-                    && mActivity.getIntent() != getParentIntent()) {
-                boolean mayLaunch = FeatureUtilities.isDocumentMode(mActivity)
+                    && getActivity().getIntent() != getParentIntent()) {
+                boolean mayLaunch = FeatureUtilities.isDocumentMode(mApplicationContext)
                         ? isParentInAndroidOverview() : true;
-                if (mayLaunch) mActivity.startActivity(getParentIntent());
+                if (mayLaunch) getActivity().startActivity(getParentIntent());
             }
         }
 
         /** If the API allows it, returns whether a Task still exists for the parent Activity. */
         @TargetApi(Build.VERSION_CODES.LOLLIPOP)
         private boolean isParentInAndroidOverview() {
-            ActivityManager activityManager =
-                    (ActivityManager) mActivity.getSystemService(Context.ACTIVITY_SERVICE);
+            ActivityManager activityManager = (ActivityManager) mApplicationContext.
+                    getSystemService(Context.ACTIVITY_SERVICE);
             for (ActivityManager.AppTask task : activityManager.getAppTasks()) {
                 Intent taskIntent = DocumentUtils.getBaseIntentFromTask(task);
                 if (taskIntent != null && taskIntent.filterEquals(getParentIntent())) return true;
             }
             return false;
         }
     };
 
     /**
      * A default {@link ChromeContextMenuItemDelegate} that supports some of the context menu
@@ skipping 42 matching lines @@
             mClipboard.setText(text, text);
         }
 
         @Override
         public void onSaveImageToClipboard(String url) {
             mClipboard.setHTMLText("<img src=\"" + url + "\">", url, url);
         }
 
         @Override
         public void onOpenInNewTab(String url, Referrer referrer) {
+            if (getTabModelSelector() == null) return;
             RecordUserAction.record("MobileNewTabOpened");
             LoadUrlParams loadUrlParams = new LoadUrlParams(url);
             loadUrlParams.setReferrer(referrer);
-            mActivity.getTabModelSelector().openNewTab(loadUrlParams,
+            getTabModelSelector().openNewTab(loadUrlParams,
                     TabLaunchType.FROM_LONGPRESS_BACKGROUND, Tab.this, isIncognito());
         }
 
         @Override
         public void onReloadIgnoringCache() {
             reloadIgnoringCache();
         }
 
         @Override
         public void onLoadOriginalImage() {
             if (mNativeTabAndroid != 0) nativeLoadOriginalImage(mNativeTabAndroid);
         }
 
         @Override
         public void onOpenInNewIncognitoTab(String url) {
+            if (getTabModelSelector() == null) return;
             RecordUserAction.record("MobileNewTabOpened");
-            mActivity.getTabModelSelector().openNewTab(new LoadUrlParams(url),
+            getTabModelSelector().openNewTab(new LoadUrlParams(url),
                     TabLaunchType.FROM_LONGPRESS_FOREGROUND, Tab.this, true);
         }
 
         @Override
         public String getPageUrl() {
             return getUrl();
         }
 
         @Override
         public void onOpenImageUrl(String url, Referrer referrer) {
             LoadUrlParams loadUrlParams = new LoadUrlParams(url);
             loadUrlParams.setTransitionType(PageTransition.LINK);
             loadUrlParams.setReferrer(referrer);
             loadUrl(loadUrlParams);
         }
 
         @Override
         public void onOpenImageInNewTab(String url, Referrer referrer) {
+            if (getTabModelSelector() == null) return;
             boolean useOriginal = isSpdyProxyEnabledForUrl(url);
             LoadUrlParams loadUrlParams = new LoadUrlParams(url);
             loadUrlParams.setVerbatimHeaders(useOriginal ? PAGESPEED_PASSTHROUGH_HEADERS : null);
             loadUrlParams.setReferrer(referrer);
-            mActivity.getTabModelSelector().openNewTab(loadUrlParams,
+            getTabModelSelector().openNewTab(loadUrlParams,
                     TabLaunchType.FROM_LONGPRESS_BACKGROUND, Tab.this, isIncognito());
         }
 
         @Override
         public void onSearchByImageInNewTab() {
             triggerSearchByImage();
         }
     }
 
     /**
@@ skipping 21 matching lines @@
         @Override
         public void onUpdateUrl(String url) {
             for (TabObserver observer : mObservers) observer.onUpdateUrl(Tab.this, url);
         }
 
         @Override
         public void showRepostFormWarningDialog() {
             // When the dialog is visible, keeping the refresh animation active
             // in the background is distracting and unnecessary (and likely to
             // jank when the dialog is shown).
-            if (mSwipeRefreshHandler != null) {
-                mSwipeRefreshHandler.reset();
-            }
+            if (mSwipeRefreshHandler != null) mSwipeRefreshHandler.reset();
+            if (getActivity() == null) return;
             RepostFormWarningDialog warningDialog = new RepostFormWarningDialog(
                     new Runnable() {
                         @Override
                         public void run() {
                             getWebContents().getNavigationController().cancelPendingReload();
                         }
                     }, new Runnable() {
                         @Override
                         public void run() {
                             getWebContents().getNavigationController().continuePendingReload();
                         }
                     });
-            warningDialog.show(mActivity.getFragmentManager(), null);
+            warningDialog.show(getActivity().getFragmentManager(), null);
         }
 
         @Override
         public void toggleFullscreenModeForTab(boolean enableFullscreen) {
             if (mFullscreenManager != null) {
                 mFullscreenManager.setPersistentFullscreenMode(enableFullscreen);
             }
 
             for (TabObserver observer : mObservers) {
                 observer.onToggleFullscreenMode(Tab.this, enableFullscreen);
@@ skipping 21 matching lines @@
             for (TabObserver observer : mObservers) observer.onSSLStateUpdated(Tab.this);
         }
 
         @Override
         public void webContentsCreated(WebContents sourceWebContents, long openerRenderFrameId,
                 String frameName, String targetUrl, WebContents newWebContents) {
             for (TabObserver observer : mObservers) {
                 observer.webContentsCreated(Tab.this, sourceWebContents, openerRenderFrameId,
                         frameName, targetUrl, newWebContents);
             }
+            if (getActivity() == null) return;
             // The URL can't be taken from the WebContents if it's paused.  Save it for later.
             assert mWebContentsUrlMapping == null;
             mWebContentsUrlMapping = Pair.create(newWebContents, targetUrl);
 
             // TODO(dfalcantara): Re-remove this once crbug.com/508366 is fixed.
-            TabCreator tabCreator = mActivity.getTabCreator(isIncognito());
+            TabCreator tabCreator = getActivity().getTabCreator(isIncognito());
 
             if (tabCreator != null && tabCreator.createsTabsAsynchronously()) {
                 DocumentWebContentsDelegate.getInstance().attachDelegate(newWebContents);
             }
         }
 
         @Override
         public void rendererUnresponsive() {
             super.rendererUnresponsive();
             if (mNativeTabAndroid != 0) nativeOnRendererUnresponsive(mNativeTabAndroid);
@@ skipping 21 matching lines @@
         @Override
         public void openNewTab(String url, String extraHeaders, byte[] postData, int disposition,
                 boolean isRendererInitiated) {
             Tab.this.openNewTab(
                     url, extraHeaders, postData, disposition, true, isRendererInitiated);
         }
 
         private Pair<WebContents, String> mWebContentsUrlMapping;
 
         protected TabModel getTabModel() {
+            if (getTabModelSelector() == null) return null;
             // TODO(dfalcantara): Remove this when DocumentActivity.getTabModelSelector()
             //                    can return a TabModelSelector that activateContents() can use.
-            return mActivity.getTabModelSelector().getModel(isIncognito());
+            return getTabModelSelector().getModel(isIncognito());
         }
 
         @Override
         public boolean shouldResumeRequestsForCreatedWindow() {
+            if (getActivity() == null) return false;
             // Pause the WebContents if an Activity has to be created for it first.
-            TabCreator tabCreator = mActivity.getTabCreator(isIncognito());
+            TabCreator tabCreator = getActivity().getTabCreator(isIncognito());
             assert tabCreator != null;
             return !tabCreator.createsTabsAsynchronously();
         }
 
         @Override
         public boolean addNewContents(WebContents sourceWebContents, WebContents webContents,
                 int disposition, Rect initialPosition, boolean userGesture) {
             assert mWebContentsUrlMapping.first == webContents;
-
-            TabCreator tabCreator = mActivity.getTabCreator(isIncognito());
+            if (getActivity() == null) return false;
+            TabCreator tabCreator = getActivity().getTabCreator(isIncognito());
             assert tabCreator != null;
 
             // Grab the URL, which might not be available via the Tab.
             String url = mWebContentsUrlMapping.second;
             mWebContentsUrlMapping = null;
 
             // Skip opening a new Tab if it doesn't make sense.
             if (isClosing()) return false;
 
             // Creating new Tabs asynchronously requires starting a new Activity to create the Tab,
             // so the Tab returned will always be null.  There's no way to know synchronously
             // whether the Tab is created, so assume it's always successful.
             boolean createdSuccessfully = tabCreator.createTabWithWebContents(
                     webContents, getId(), TabLaunchType.FROM_LONGPRESS_FOREGROUND, url);
             boolean success = tabCreator.createsTabsAsynchronously() || createdSuccessfully;
             if (success && disposition == WindowOpenDisposition.NEW_POPUP) {
                 PolicyAuditor auditor =
                         ((ChromeApplication) getApplicationContext()).getPolicyAuditor();
                 auditor.notifyAuditEvent(getApplicationContext(), AuditEvent.OPEN_POPUP_URL_SUCCESS,
                         url, "");
             }
 
             return success;
         }
 
         @Override
         public void activateContents() {
             boolean activityIsDestroyed = false;
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-                activityIsDestroyed = mActivity.isDestroyed();
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1
+                    && getActivity() != null) {
+                activityIsDestroyed = getActivity().isDestroyed();
             }
             if (activityIsDestroyed || !isInitialized()) {
                 Log.e(TAG, "Activity destroyed before calling activateContents().  Bailing out.");
                 return;
             }
 
             TabModel model = getTabModel();
             int index = model.indexOf(Tab.this);
             if (index == TabModel.INVALID_TAB_INDEX) return;
             TabModelUtils.setIndex(model, index);
@@ skipping 23 matching lines @@
         @Override
         public void closeContents() {
             // Execute outside of callback, otherwise we end up deleting the native
             // objects in the middle of executing methods on them.
             mHandler.removeCallbacks(mCloseContentsRunnable);
             mHandler.post(mCloseContentsRunnable);
         }
 
         @Override
         public boolean takeFocus(boolean reverse) {
+            if (getActivity() == null) return false;
+            Activity activity = getActivity();
             if (reverse) {
-                View menuButton = mActivity.findViewById(R.id.menu_button);
+                View menuButton = activity.findViewById(R.id.menu_button);
                 if (menuButton == null || !menuButton.isShown()) {
-                    menuButton = mActivity.findViewById(R.id.document_menu_button);
+                    menuButton = activity.findViewById(R.id.document_menu_button);
                 }
                 if (menuButton != null && menuButton.isShown()) {
                     return menuButton.requestFocus();
                 }
 
-                View tabSwitcherButton = mActivity.findViewById(R.id.tab_switcher_button);
+                View tabSwitcherButton = activity.findViewById(R.id.tab_switcher_button);
                 if (tabSwitcherButton != null && tabSwitcherButton.isShown()) {
                     return tabSwitcherButton.requestFocus();
                 }
             } else {
-                View urlBar = mActivity.findViewById(R.id.url_bar);
+                View urlBar = activity.findViewById(R.id.url_bar);
                 if (urlBar != null) return urlBar.requestFocus();
             }
             return false;
         }
 
         @Override
         public void handleKeyboardEvent(KeyEvent event) {
+            if (getActivity() == null) return;
             if (event.getAction() == KeyEvent.ACTION_DOWN) {
-                if (mActivity.onKeyDown(event.getKeyCode(), event)) return;
+                if (getActivity().onKeyDown(event.getKeyCode(), event)) return;
 
                 // Handle the Escape key here (instead of in KeyboardShortcuts.java), so it doesn't
                 // interfere with other parts of the activity (e.g. the URL bar).
                 if (event.getKeyCode() == KeyEvent.KEYCODE_ESCAPE && event.hasNoModifiers()) {
                     WebContents wc = getWebContents();
                     if (wc != null) wc.stop();
                     return;
                 }
             }
             handleMediaKey(event);
@@ skipping 14 matching lines @@
                 case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                 case KeyEvent.KEYCODE_MEDIA_STOP:
                 case KeyEvent.KEYCODE_MEDIA_NEXT:
                 case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                 case KeyEvent.KEYCODE_MEDIA_REWIND:
                 case KeyEvent.KEYCODE_MEDIA_RECORD:
                 case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
                 case KeyEvent.KEYCODE_MEDIA_CLOSE:
                 case KeyEvent.KEYCODE_MEDIA_EJECT:
                 case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
-                    AudioManager am = (AudioManager) mActivity.getSystemService(
+                    AudioManager am = (AudioManager) mApplicationContext.getSystemService(
                             Context.AUDIO_SERVICE);
                     am.dispatchMediaKeyEvent(e);
                     break;
                 default:
                     break;
             }
         }
 
         /**
          * @return Whether audio is being captured.
@@ skipping 58 matching lines @@
             updateFullscreenEnabledState();
         }
 
         @Override
         public boolean doesPerformWebSearch() {
             return true;
         }
 
         @Override
         public void performWebSearch(String searchQuery) {
-            if (TextUtils.isEmpty(searchQuery)) return;
+            if (TextUtils.isEmpty(searchQuery) || getTabModelSelector() == null) return;
             String url = TemplateUrlService.getInstance().getUrlForSearchQuery(searchQuery);
             String headers = GeolocationHeader.getGeoHeader(getApplicationContext(), url,
                     isIncognito());
 
             LoadUrlParams loadUrlParams = new LoadUrlParams(url);
             loadUrlParams.setVerbatimHeaders(headers);
             loadUrlParams.setTransitionType(PageTransition.GENERATED);
-            mActivity.getTabModelSelector().openNewTab(loadUrlParams,
+            getTabModelSelector().openNewTab(loadUrlParams,
                     TabLaunchType.FROM_LONGPRESS_FOREGROUND, Tab.this, isIncognito());
         }
 
         @Override
         public ContentVideoViewClient getContentVideoViewClient() {
-            return new ActivityContentVideoViewClient(mActivity) {
+            assert getActivity() != null;
+            return new ActivityContentVideoViewClient(getActivity()) {
                 @Override
                 public void enterFullscreenVideo(View view) {
                     super.enterFullscreenVideo(view);
                     FullscreenManager fullscreenManager = getFullscreenManager();
                     if (fullscreenManager != null) {
                         fullscreenManager.setOverlayVideoMode(true);
                         // Disable double tap for video.
                         if (getContentViewCore() != null) {
                             getContentViewCore().updateDoubleTapSupport(false);
                         }
@@ skipping 234 matching lines @@
 
     /**
      * Creates an instance of a {@link Tab}.
      * @param id          The id this tab should be identified with.
      * @param parentId    The id id of the tab that caused this tab to be opened.
      * @param incognito   Whether or not this tab is incognito.
      * @param activity     An instance of a {@link Context}.
      * @param window      An instance of a {@link WindowAndroid}.
      * @param frozenState State containing information about this Tab, if it was persisted.
      */
-    public Tab(int id, int parentId, boolean incognito, ChromeActivity activity,
+    public Tab(int id, int parentId, boolean incognito, Context context,
             WindowAndroid window, TabLaunchType type, TabState frozenState) {
         mId = TabIdManager.getInstance().generateValidId(id);
         mParentId = parentId;
         mIncognito = incognito;
-        mActivity = activity;
-        mApplicationContext = activity != null ? activity.getApplicationContext() : null;
+        mApplicationContext = context != null ? context.getApplicationContext() : null;
+        mThemedContext = new ContextThemeWrapper(mApplicationContext, R.style.MainTheme);
         mWindowAndroid = window;
         mLaunchType = type;
-        if (mActivity != null) {
-            Resources resources = mActivity.getResources();
+        if (mApplicationContext != null) {
+            Resources resources = mApplicationContext.getResources();
             mIdealFaviconSize = resources.getDimensionPixelSize(R.dimen.default_favicon_size);
             mDefaultThemeColor = mIncognito
                     ? ApiCompatibilityUtils.getColor(resources, R.color.incognito_primary_color)
                     : ApiCompatibilityUtils.getColor(resources, R.color.default_primary_color);
             mThemeColor = mDefaultThemeColor;
         } else {
             mIdealFaviconSize = 16;
             mDefaultThemeColor = 0;
         }
 
@@ skipping 11 matching lines @@
             @Override
             public void handleMessage(Message msg) {
                 if (msg == null) return;
                 if (msg.what == MSG_ID_ENABLE_FULLSCREEN_AFTER_LOAD) {
                     enableFullscreenAfterLoad();
                 }
             }
         };
     }
 
+    protected ChromeActivity getActivity() {
+        if (getWindowAndroid() == null) return null;
+        Activity activity = getWindowAndroid().getActivity().get();
+        if (!(activity instanceof ChromeActivity)) return null;
+        return (ChromeActivity) activity;
+    }
+
+    protected TabModelSelector getTabModelSelector() {
+        if (getActivity() == null) return null;
+        return getActivity().getTabModelSelector();
+    }
+
     /**
      * TODO(aurimas): remove this method once Tab and ChromeTab are merged.
      */
     protected void enableFullscreenAfterLoad() {}
 
     /**
      * Sets the mTabUma object for stats reporting.
      * @param tabUma TabUma object to use to report UMA stats.
      */
     protected void setTabUma(TabUma tabUma) {
@@ skipping 235 matching lines @@
         assert mNativeTabAndroid != 0;
         return nativePrint(mNativeTabAndroid);
     }
 
     @CalledByNative
     public void setPendingPrint() {
         PrintingController printingController = PrintingControllerImpl.getInstance();
         if (printingController == null) return;
 
         printingController.setPendingPrint(new TabPrinter(this),
-                new PrintManagerDelegateImpl(mActivity));
+                new PrintManagerDelegateImpl(mApplicationContext));
     }
 
     /**
      * Reloads the current page content.
      */
     public void reload() {
         // TODO(dtrainor): Should we try to rebuild the ContentView if it's frozen?
         if (getWebContents() != null) getWebContents().getNavigationController().reload(true);
     }
 
@@ skipping 385 matching lines @@
         if (AppBannerManager.isEnabled()) {
             mAppBannerManager = createAppBannerManager();
             if (mAppBannerManager != null) addObserver(mAppBannerManager);
         }
     }
 
     /**
      * @return {@link AppBannerManager} to be used for this tab. May be null.
      */
     protected AppBannerManager createAppBannerManager() {
-        return new AppBannerManager(this, mActivity);
+        return new AppBannerManager(this);
     }
 
     /**
      * Used to get a list of Android {@link View}s that represent both the normal content as well as
      * overlays.  This does not return {@link View}s for {@link NativePage}s.
      * @param content A {@link List} that will be populated with {@link View}s that represent all of
      *                the content in this {@link Tab}.
      */
     public void getAllContentViews(List<View> content) {
         if (!isNativePage()) {
@@ skipping 131 matching lines @@
         mIsInitialized = true;
     }
 
     /**
      * Creates and initializes the {@link ContentViewCore}.
      *
      * @param webContents The WebContents object that will be used to build the
      *                    {@link ContentViewCore}.
      */
     protected void initContentViewCore(WebContents webContents) {
-        ContentViewCore cvc = new ContentViewCore(mActivity);
-        ContentView cv = ContentView.createContentView(mActivity, cvc);
-        cv.setContentDescription(mActivity.getResources().getString(
+        ContentViewCore cvc = new ContentViewCore(mThemedContext);
+        ContentView cv = ContentView.createContentView(mThemedContext, cvc);
+        cv.setContentDescription(mApplicationContext.getResources().getString(
                 R.string.accessibility_content_view));
         cvc.initialize(cv, cv, webContents, getWindowAndroid());
         setContentViewCore(cvc);
     }
 
     /**
      * Completes the {@link ContentViewCore} specific initialization around a native WebContents
      * pointer. {@link #getNativePage()} will still return the {@link NativePage} if there is one.
      * All initialization that needs to reoccur after a web contents swap should be added here.
      * <p />
@@ skipping 13 matching lines @@
 
         // Wrap the ContentView in a FrameLayout, which will contain both the ContentView and the
         // InfoBarContainer. The alternative -- placing the InfoBarContainer inside the ContentView
         // -- causes problems since then the ContentView would contain both real views (the
         // infobars) and virtual views (the web page elements), which breaks Android accessibility.
         // http://crbug.com/416663
         if (mContentViewParent != null) {
             assert false;
             mContentViewParent.removeAllViews();
         }
-        mContentViewParent = new FrameLayout(mActivity);
+        mContentViewParent = new FrameLayout(mThemedContext);
         mContentViewParent.addView(cvc.getContainerView(),
                 new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
 
         mWebContentsDelegate = createWebContentsDelegate();
         mWebContentsObserver = new TabWebContentsObserver(mContentViewCore.getWebContents());
 
         if (mContentViewClient != null) mContentViewCore.setContentViewClient(mContentViewClient);
 
         assert mNativeTabAndroid != 0;
         nativeInitWebContents(
                 mNativeTabAndroid, mIncognito, mContentViewCore, mWebContentsDelegate,
                 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(mActivity, getId(), mContentViewParent, this);
+            mInfoBarContainer = new InfoBarContainer(
+                    mThemedContext, getId(), mContentViewParent, this);
         } else {
             mInfoBarContainer.onParentViewChanged(getId(), mContentViewParent);
         }
         mInfoBarContainer.setContentViewCore(mContentViewCore);
 
-        mSwipeRefreshHandler = new SwipeRefreshHandler(mActivity);
+        mSwipeRefreshHandler = new SwipeRefreshHandler(mThemedContext);
         mSwipeRefreshHandler.setContentViewCore(mContentViewCore);
 
         for (TabObserver observer : mObservers) observer.onContentChanged(this);
 
         // For browser tabs, we want to set accessibility focus to the page
         // when it loads. This is not the default behavior for embedded
         // web views.
         mContentViewCore.setShouldSetAccessibilityFocusOnPageLoad(true);
 
-        mDownloadDelegate = new ChromeDownloadDelegate(mActivity,
-                mActivity.getTabModelSelector(), this);
+        mDownloadDelegate = new ChromeDownloadDelegate(mThemedContext, this);
         cvc.setDownloadDelegate(mDownloadDelegate);
     }
 
+    public boolean closeTab() {
+        if (getTabModelSelector() == null) return false;
+        return getTabModelSelector().closeTab(this);
+    }
+
     /**
      * Constructs and shows a sad tab (Aw, Snap!).
      */
     protected void showSadTab() {
         if (getContentViewCore() != null) {
             OnClickListener suggestionAction = new OnClickListener() {
                 @Override
                 public void onClick(View view) {
                     Activity activity = mWindowAndroid.getActivity().get();
                     assert activity != null;
                     HelpAndFeedback.getInstance(activity).show(activity,
                             activity.getString(R.string.help_context_sad_tab),
                             Profile.getLastUsedProfile(), null);
                 }
             };
             OnClickListener reloadButtonAction = new OnClickListener() {
                 @Override
                 public void onClick(View view) {
                     reload();
                 }
             };
 
             // Make sure we are not adding the "Aw, snap" view over an existing one.
             assert mSadTabView == null;
             mSadTabView = SadTabViewFactory.createSadTabView(
-                    mActivity, suggestionAction, reloadButtonAction);
+                    mThemedContext, suggestionAction, reloadButtonAction);
 
             // Show the sad tab inside ContentView.
             getContentViewCore().getContainerView().addView(
                     mSadTabView, new FrameLayout.LayoutParams(
                             LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
             for (TabObserver observer : mObservers) observer.onContentChanged(this);
         }
         FullscreenManager fullscreenManager = getFullscreenManager();
         if (fullscreenManager != null) {
             fullscreenManager.setPositionsForTabToNonFullscreen();
@@ skipping 185 matching lines @@
     }
 
     /**
      * Loads the tab if it's not loaded (e.g. because it was killed in background).
      * This will trigger a regular load for tabs with pending lazy first load (tabs opened in
      * background on low-memory devices).
      * @return true iff the Tab handled the request.
      */
     @CalledByNative
     public boolean loadIfNeeded() {
-        if (mActivity == null) {
+        if (getActivity() == null) {
             Log.e(TAG, "Tab couldn't be loaded because Context was null.");
             return false;
         }
 
         if (mPendingLoadParams != null) {
             assert isFrozen();
             initContentViewCore(WebContentsFactory.createWebContents(isIncognito(), isHidden()));
             loadUrl(mPendingLoadParams);
             mPendingLoadParams = null;
             return true;
@@ skipping 293 matching lines @@
     @CalledByNative
     protected void onNavEntryChanged() {
         mIsTabStateDirty = true;
     }
 
     /**
      * Returns the SnackbarManager for the activity that owns this Tab, if any. May
      * return null.
      */
     public SnackbarManager getSnackbarManager() {
-        return mActivity.getSnackbarManager();
+        return getActivity() != null ? getActivity().getSnackbarManager() : null;
     }
 
     /**
      * @return The native pointer representing the native side of this {@link Tab} object.
      */
     @CalledByNative
     private long getNativePtr() {
         return mNativeTabAndroid;
     }
 
     /** This is currently called when committing a pre-rendered page. */
     @VisibleForTesting
     @CalledByNative
     public void swapWebContents(
             WebContents webContents, boolean didStartLoad, boolean didFinishLoad) {
-        ContentViewCore cvc = new ContentViewCore(mActivity);
-        ContentView cv = ContentView.createContentView(mActivity, cvc);
-        cv.setContentDescription(mActivity.getResources().getString(
+        ContentViewCore cvc = new ContentViewCore(mThemedContext);
+        ContentView cv = ContentView.createContentView(mThemedContext, cvc);
+        cv.setContentDescription(mApplicationContext.getResources().getString(
                 R.string.accessibility_content_view));
         cvc.initialize(cv, cv, webContents, getWindowAndroid());
         swapContentViewCore(cvc, false, didStartLoad, didFinishLoad);
     }
 
     /**
      * Called to swap out the current view with the one passed in.
      *
      * @param newContentViewCore The content view that should be swapped into the tab.
      * @param deleteOldNativeWebContents Whether to delete the native web
@@ skipping 438 matching lines @@
             case WindowOpenDisposition.OFF_THE_RECORD:
                 assert incognito;
                 incognito = true;
                 break;
             default:
                 assert false;
         }
 
         // If shouldIgnoreNewTab returns true, the intent is handled by another
         // activity. As a result, don't launch a new tab to open the URL.
-        if (shouldIgnoreNewTab(url, incognito)) return;
+        if (shouldIgnoreNewTab(url, incognito) || getTabModelSelector() == null) return;
 
         LoadUrlParams loadUrlParams = new LoadUrlParams(url);
         loadUrlParams.setVerbatimHeaders(extraHeaders);
         loadUrlParams.setPostData(postData);
         loadUrlParams.setIsRendererInitiated(isRendererInitiated);
-        mActivity.getTabModelSelector().openNewTab(
+        getTabModelSelector().openNewTab(
                 loadUrlParams, tabLaunchType, parentTab, incognito);
     }
 
     /**
      * @return True if the Tab should block the creation of new tabs via {@link #openNewTab}.
      */
     protected boolean shouldIgnoreNewTab(String url, boolean incognito) {
         return false;
     }
 
@@ skipping 191 matching lines @@
     private native void nativeAttachOverlayContentViewCore(long nativeTabAndroid,
             ContentViewCore content, boolean visible);
     private native void nativeDetachOverlayContentViewCore(long nativeTabAndroid,
             ContentViewCore content);
     private native boolean nativeHasPrerenderedUrl(long nativeTabAndroid, String url);
     private native void nativeOnRendererUnresponsive(long nativeTabAndroid);
     private native void nativeOnRendererResponsive(long nativeTabAndroid);
 
     private static native void nativeRecordStartupToCommitUma();
 }