Remove some TabContentses from extensions.

chrome/browser/extensions/api/tabs/tabs.cc

 // Copyright (c) 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.
 
 #include "chrome/browser/extensions/api/tabs/tabs.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 155 matching lines @@
     *controller = WindowControllerList::GetInstance()->
         FindWindowForFunctionById(function, window_id);
     if (!(*controller)) {
       function->SetError(ExtensionErrorUtils::FormatErrorMessage(
           keys::kWindowNotFoundError, base::IntToString(window_id)));
       return false;
     }
   }
   return true;
 }
+
 // |error_message| can optionally be passed in and will be set with an
 // appropriate message if the tab cannot be found by id.
 bool GetTabById(int tab_id,
                 Profile* profile,
                 bool include_incognito,
                 Browser** browser,
                 TabStripModel** tab_strip,
-                TabContents** contents,
+                content::WebContents** contents,
                 int* tab_index,
                 std::string* error_message) {
   if (ExtensionTabUtil::GetTabById(tab_id, profile, include_incognito,
                                    browser, tab_strip, contents, tab_index))
     return true;
 
   if (error_message)
     *error_message = ExtensionErrorUtils::FormatErrorMessage(
         keys::kTabNotFoundError, base::IntToString(tab_id));
 
@@ skipping 241 matching lines @@
     }
   }
 
   // Look for optional tab id.
   if (args) {
     int tab_id = -1;
     if (args->HasKey(keys::kTabIdKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kTabIdKey, &tab_id));
 
       // Find the tab and detach it from the original window.
-      Browser* source_browser = NULL;
       TabStripModel* source_tab_strip = NULL;
       int tab_index = -1;
       if (!GetTabById(tab_id, profile(), include_incognito(),
-                      &source_browser, &source_tab_strip, &contents,
-                      &tab_index, &error_))
+                      NULL, &source_tab_strip,
+                      NULL, &tab_index, &error_))
         return false;
       contents = source_tab_strip->DetachTabContentsAt(tab_index);
       if (!contents) {
         error_ = ExtensionErrorUtils::FormatErrorMessage(
             keys::kTabNotFoundError, base::IntToString(tab_id));
         return false;
       }
     }
   }
 
@@ skipping 538 matching lines @@
     return false;
 
   // TODO(jstritar): Add a constant, chrome.tabs.TAB_ID_ACTIVE, that
   // represents the active tab.
   WebContents* opener = NULL;
   if (args->HasKey(keys::kOpenerTabIdKey)) {
     int opener_id = -1;
     EXTENSION_FUNCTION_VALIDATE(args->GetInteger(
         keys::kOpenerTabIdKey, &opener_id));
 
-    TabContents* opener_contents = NULL;
     if (!ExtensionTabUtil::GetTabById(
             opener_id, profile(), include_incognito(),
-            NULL, NULL, &opener_contents, NULL))
+            NULL, NULL, &opener, NULL))
       return false;
-
-    opener = opener_contents->web_contents();
   }
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
   std::string url_string;
   GURL url;
   if (args->HasKey(keys::kUrlKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kUrlKey,
@@ skipping 83 matching lines @@
 
   return true;
 }
 
 bool DuplicateTabFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   Browser* browser = NULL;
   TabStripModel* tab_strip = NULL;
-  TabContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
-                  &browser, &tab_strip, &contents, &tab_index, &error_)) {
+                  &browser, &tab_strip, NULL, &tab_index, &error_)) {
     return false;
   }
 
   TabContents* new_contents = chrome::DuplicateTabAt(browser, tab_index);
   if (!has_callback())
     return true;
 
   int new_index = tab_strip->GetIndexOfTabContents(new_contents);
 
   // Return data about the newly created tab.
   SetResult(ExtensionTabUtil::CreateTabValue(
       new_contents->web_contents(),
       tab_strip, new_index, GetExtension()));
 
   return true;
 }
 
 bool GetTabFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
-  TabContents* contents = NULL;
+  WebContents* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_))
     return false;
 
-  SetResult(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
+  SetResult(ExtensionTabUtil::CreateTabValue(contents,
                                              tab_strip,
                                              tab_index,
                                              GetExtension()));
   return true;
 }
 
 bool GetCurrentTabFunction::RunImpl() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
@@ skipping 53 matching lines @@
   }
 
   selection.set_active(active_index);
   browser->tab_strip_model()->SetSelectionFromModel(selection);
   SetResult(
       browser->extension_window_controller()->CreateWindowValueWithTabs(
           GetExtension()));
   return true;
 }
 
-UpdateTabFunction::UpdateTabFunction() : tab_contents_(NULL) {
+UpdateTabFunction::UpdateTabFunction() : web_contents_(NULL) {
 }
 
 bool UpdateTabFunction::RunImpl() {
   DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   Value* tab_value = NULL;
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
   }
 
   int tab_id = -1;
-  TabContents* contents = NULL;
+  WebContents* contents = NULL;
   if (tab_value == NULL || tab_value->IsType(Value::TYPE_NULL)) {
     Browser* browser = GetCurrentBrowser();
     if (!browser) {
       error_ = keys::kNoCurrentWindowError;
       return false;
     }
-    contents = browser->tab_strip_model()->GetActiveTabContents();
+    contents = browser->tab_strip_model()->GetActiveWebContents();
     if (!contents) {
       error_ = keys::kNoSelectedTabError;
       return false;
     }
-    tab_id = SessionID::IdForTab(contents->web_contents());
+    tab_id = SessionID::IdForTab(contents);
   } else {
     EXTENSION_FUNCTION_VALIDATE(tab_value->GetAsInteger(&tab_id));
   }
 
   int tab_index = -1;
   TabStripModel* tab_strip = NULL;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_)) {
     return false;
   }
 
-  tab_contents_ = contents;
+  web_contents_ = contents;
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
   // Navigate the tab to a new location if the url is different.
   bool is_async = false;
   if (!UpdateURLIfPresent(update_props, tab_id, &is_async))
     return false;
 
   bool active = false;
   // TODO(rafaelw): Setting |active| from js doesn't make much sense.
   // Move tab selection management up to window.
   if (update_props->HasKey(keys::kSelectedKey))
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kSelectedKey, &active));
 
   // The 'active' property has replaced 'selected'.
   if (update_props->HasKey(keys::kActiveKey))
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kActiveKey, &active));
 
   if (active) {
     if (tab_strip->active_index() != tab_index) {
       tab_strip->ActivateTabAt(tab_index, false);
-      DCHECK_EQ(contents, tab_strip->GetActiveTabContents());
+      DCHECK_EQ(contents, tab_strip->GetActiveWebContents());
     }
-    tab_contents_->web_contents()->Focus();
+    web_contents_->Focus();
   }
 
   if (update_props->HasKey(keys::kHighlightedKey)) {
     bool highlighted = false;
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kHighlightedKey, &highlighted));
     if (highlighted != tab_strip->IsTabSelected(tab_index))
       tab_strip->ToggleSelectionAt(tab_index);
   }
 
   if (update_props->HasKey(keys::kPinnedKey)) {
     bool pinned = false;
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kPinnedKey, &pinned));
     tab_strip->SetTabPinned(tab_index, pinned);
 
     // Update the tab index because it may move when being pinned.
-    tab_index = tab_strip->GetIndexOfTabContents(contents);
+    tab_index = tab_strip->GetIndexOfWebContents(contents);
   }
 
   if (update_props->HasKey(keys::kOpenerTabIdKey)) {
     int opener_id = -1;
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kOpenerTabIdKey, &opener_id));
 
-    TabContents* opener_contents = NULL;
+    WebContents* opener_contents = NULL;
     if (!ExtensionTabUtil::GetTabById(
             opener_id, profile(), include_incognito(),
             NULL, NULL, &opener_contents, NULL))
       return false;
 
-    tab_strip->SetOpenerOfWebContentsAt(
-        tab_index, opener_contents->web_contents());
+    tab_strip->SetOpenerOfWebContentsAt(tab_index, opener_contents);
   }
 
   if (!is_async) {
     PopulateResult();
     SendResponse(true);
   }
   return true;
 }
 
 bool UpdateTabFunction::UpdateURLIfPresent(DictionaryValue* update_props,
@@ skipping 17 matching lines @@
   // Don't let the extension crash the browser or renderers.
   if (ExtensionTabUtil::IsCrashURL(url)) {
     error_ = keys::kNoCrashBrowserError;
     return false;
   }
 
   // JavaScript URLs can do the same kinds of things as cross-origin XHR, so
   // we need to check host permissions before allowing them.
   if (url.SchemeIs(chrome::kJavaScriptScheme)) {
     if (!GetExtension()->CanExecuteScriptOnPage(
-            tab_contents_->web_contents()->GetURL(),
-            tab_contents_->web_contents()->GetURL(),
+            web_contents_->GetURL(),
+            web_contents_->GetURL(),
             tab_id,
             NULL,
             &error_)) {
       return false;
     }
 
-    extensions::TabHelper::FromWebContents(tab_contents_->web_contents())->
+    extensions::TabHelper::FromWebContents(web_contents_)->
         script_executor()->ExecuteScript(
             extension_id(),
             ScriptExecutor::JAVASCRIPT,
             url.path(),
             ScriptExecutor::TOP_FRAME,
             extensions::UserScript::DOCUMENT_IDLE,
             ScriptExecutor::MAIN_WORLD,
             base::Bind(&UpdateTabFunction::OnExecuteCodeFinished, this));
 
     *is_async = true;
     return true;
   }
 
-  tab_contents_->web_contents()->GetController().LoadURL(
+  web_contents_->GetController().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
 
   // The URL of a tab contents never actually changes to a JavaScript URL, so
   // this check only makes sense in other cases.
   if (!url.SchemeIs(chrome::kJavaScriptScheme))
-    DCHECK_EQ(url.spec(), tab_contents_->web_contents()->GetURL().spec());
+    DCHECK_EQ(url.spec(), web_contents_->GetURL().spec());
 
   return true;
 }
 
 void UpdateTabFunction::PopulateResult() {
   if (!has_callback())
     return;
 
-  SetResult(ExtensionTabUtil::CreateTabValue(tab_contents_->web_contents(),
-                                             GetExtension()));
+  SetResult(ExtensionTabUtil::CreateTabValue(web_contents_, GetExtension()));
 }
 
 void UpdateTabFunction::OnExecuteCodeFinished(const std::string& error,
                                               int32 on_page_id,
                                               const GURL& url,
                                               const ListValue& script_result) {
   if (error.empty())
     PopulateResult();
   else
     error_ = error;
@@ skipping 11 matching lines @@
   DictionaryValue* update_props = NULL;
   int new_index;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
   EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(keys::kIndexKey,
       &new_index));
 
   ListValue tab_values;
   for (size_t i = 0; i < tab_ids.size(); ++i) {
     Browser* source_browser = NULL;
     TabStripModel* source_tab_strip = NULL;
-    TabContents* contents = NULL;
+    WebContents* contents = NULL;
     int tab_index = -1;
     if (!GetTabById(tab_ids[i], profile(), include_incognito(),
                     &source_browser, &source_tab_strip, &contents,
                     &tab_index, &error_))
       return false;
 
     // Don't let the extension move the tab if the user is dragging tabs.
     if (!chrome::IsTabStripEditable(source_browser)) {
       error_ = keys::kTabStripNotEditableError;
       return false;
@@ skipping 23 matching lines @@
 
       if (target_browser->profile() != source_browser->profile()) {
         error_ = keys::kCanOnlyMoveTabsWithinSameProfileError;
         return false;
       }
 
       // If windowId is different from the current window, move between windows.
       if (ExtensionTabUtil::GetWindowId(target_browser) !=
           ExtensionTabUtil::GetWindowId(source_browser)) {
         TabStripModel* target_tab_strip = target_browser->tab_strip_model();
-        contents = source_tab_strip->DetachTabContentsAt(tab_index);
-        if (!contents) {
+        TabContents* tab_contents =
+            source_tab_strip->DetachTabContentsAt(tab_index);
+        if (!tab_contents) {
           error_ = ExtensionErrorUtils::FormatErrorMessage(
               keys::kTabNotFoundError, base::IntToString(tab_ids[i]));
           return false;
         }
 
         // Clamp move location to the last position.
         // This is ">" because it can append to a new index position.
         // -1 means set the move location to the last position.
         if (new_index > target_tab_strip->count() || new_index < 0)
           new_index = target_tab_strip->count();
 
         target_tab_strip->InsertTabContentsAt(
-            new_index, contents, TabStripModel::ADD_NONE);
+            new_index, tab_contents, TabStripModel::ADD_NONE);
 
         if (has_callback()) {
           tab_values.Append(ExtensionTabUtil::CreateTabValue(
-              contents->web_contents(),
+              tab_contents->web_contents(),
               target_tab_strip,
               new_index,
               GetExtension()));
         }
 
         continue;
       }
     }
 
     // Perform a simple within-window move.
     // Clamp move location to the last position.
     // This is ">=" because the move must be to an existing location.
     // -1 means set the move location to the last position.
     if (new_index >= source_tab_strip->count() || new_index < 0)
       new_index = source_tab_strip->count() - 1;
 
     if (new_index != tab_index)
       source_tab_strip->MoveTabContentsAt(tab_index, new_index, false);
 
     if (has_callback()) {
       tab_values.Append(ExtensionTabUtil::CreateTabValue(
-          contents->web_contents(), source_tab_strip, new_index,
-          GetExtension()));
+          contents, source_tab_strip, new_index, GetExtension()));
     }
   }
 
   if (!has_callback())
     return true;
 
   // Only return the results as an array if there are multiple tabs.
   if (tab_ids.size() > 1) {
     SetResult(tab_values.DeepCopy());
   } else if (tab_ids.size() == 1) {
@@ skipping 10 matching lines @@
       DictionaryValue* reload_props = NULL;
       EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &reload_props));
 
       if (reload_props->HasKey(keys::kBypassCache)) {
         EXTENSION_FUNCTION_VALIDATE(reload_props->GetBoolean(
             keys::kBypassCache,
             &bypass_cache));
       }
   }
 
-  TabContents* contents = NULL;
+  content::WebContents* web_contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
   // in the current window.
   Value* tab_value = NULL;
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   if (tab_value == NULL || tab_value->IsType(Value::TYPE_NULL)) {
     Browser* browser = GetCurrentBrowser();
     if (!browser) {
       error_ = keys::kNoCurrentWindowError;
       return false;
     }
 
-    if (!ExtensionTabUtil::GetDefaultTab(browser, &contents, NULL))
+    if (!ExtensionTabUtil::GetDefaultTab(browser, &web_contents, NULL))
       return false;
   } else {
     int tab_id = -1;
     EXTENSION_FUNCTION_VALIDATE(tab_value->GetAsInteger(&tab_id));
 
     Browser* browser = NULL;
     if (!GetTabById(tab_id, profile(), include_incognito(),
-                    &browser, NULL, &contents, NULL, &error_))
+                    &browser, NULL, &web_contents, NULL, &error_))
     return false;
   }
 
-  WebContents* web_contents = contents->web_contents();
   if (web_contents->ShowingInterstitialPage()) {
     // This does as same as Browser::ReloadInternal.
     NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
     OpenURLParams params(entry->GetURL(), Referrer(), CURRENT_TAB,
                          content::PAGE_TRANSITION_RELOAD, false);
     GetCurrentBrowser()->OpenURL(params);
   } else if (bypass_cache) {
     web_contents->GetController().ReloadIgnoringCache(true);
   } else {
     web_contents->GetController().Reload(true);
   }
 
   return true;
 }
 
 bool RemoveTabsFunction::RunImpl() {
   Value* tab_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &tab_value));
 
   std::vector<int> tab_ids;
   EXTENSION_FUNCTION_VALIDATE(extensions::ReadOneOrMoreIntegers(
       tab_value, &tab_ids));
 
   for (size_t i = 0; i < tab_ids.size(); ++i) {
     Browser* browser = NULL;
-    TabContents* contents = NULL;
+    WebContents* contents = NULL;
     if (!GetTabById(tab_ids[i], profile(), include_incognito(),
                     &browser, NULL, &contents, NULL, &error_))
       return false;
 
     // Don't let the extension remove a tab if the user is dragging tabs around.
     if (!chrome::IsTabStripEditable(browser)) {
       error_ = keys::kTabStripNotEditableError;
       return false;
     }
 
     // There's a chance that the tab is being dragged, or we're in some other
     // nested event loop. This code path ensures that the tab is safely closed
     // under such circumstances, whereas |chrome::CloseWebContents()| does not.
-    contents->web_contents()->Close();
+    contents->Close();
   }
   return true;
 }
 
 bool CaptureVisibleTabFunction::GetTabToCapture(WebContents** web_contents) {
   Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
@@ skipping 174 matching lines @@
 }
 
 void CaptureVisibleTabFunction::RegisterUserPrefs(PrefService* service) {
   service->RegisterBooleanPref(prefs::kDisableScreenshots, false,
                                PrefService::UNSYNCABLE_PREF);
 }
 
 bool DetectTabLanguageFunction::RunImpl() {
   int tab_id = 0;
   Browser* browser = NULL;
-  TabContents* contents = NULL;
+  WebContents* contents = NULL;
 
   // If |tab_id| is specified, look for it. Otherwise default to selected tab
   // in the current window.
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
     if (!GetTabById(tab_id, profile(), include_incognito(),
                     &browser, NULL, &contents, NULL, &error_)) {
       return false;
     }
     if (!browser || !contents)
       return false;
   } else {
     browser = GetCurrentBrowser();
     if (!browser)
       return false;
-    contents = browser->tab_strip_model()->GetActiveTabContents();
+    contents = browser->tab_strip_model()->GetActiveWebContents();
     if (!contents)
       return false;
   }
 
-  if (contents->web_contents()->GetController().NeedsReload()) {
+  if (contents->GetController().NeedsReload()) {
     // If the tab hasn't been loaded, don't wait for the tab to load.
     error_ = keys::kCannotDetermineLanguageOfUnloadedTab;
     return false;
   }
 
-  AddRef();  // Balanced in GotLanguage()
+  AddRef();  // Balanced in GotLanguage().
 
   TranslateTabHelper* translate_tab_helper =
-      TranslateTabHelper::FromWebContents(contents->web_contents());
+      TranslateTabHelper::FromWebContents(contents);
   if (!translate_tab_helper->language_state().original_language().empty()) {
     // Delay the callback invocation until after the current JS call has
     // returned.
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
         &DetectTabLanguageFunction::GotLanguage, this,
         translate_tab_helper->language_state().original_language()));
     return true;
   }
   // The tab contents does not know its language yet.  Let's wait until it
   // receives it, or until the tab is closed/navigates to some other page.
   registrar_.Add(this, chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
-                 content::Source<WebContents>(contents->web_contents()));
+                 content::Source<WebContents>(contents));
   registrar_.Add(
       this, chrome::NOTIFICATION_TAB_CLOSING,
-      content::Source<NavigationController>(
-          &(contents->web_contents()->GetController())));
+      content::Source<NavigationController>(&(contents->GetController())));
   registrar_.Add(
       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<NavigationController>(
-          &(contents->web_contents()->GetController())));
+      content::Source<NavigationController>(&(contents->GetController())));
   return true;
 }
 
 void DetectTabLanguageFunction::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   std::string language;
   if (type == chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED)
     language = *content::Details<std::string>(details).ptr();
 
   registrar_.RemoveAll();
 
   // Call GotLanguage in all cases as we want to guarantee the callback is
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   SetResult(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }