Replace most of Browser::GetSelectedTabContents calls into Browser::GetSelectedWebContents. I've ...

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2011 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/extension_tabs_module.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 28 matching lines @@
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
-#include "content/browser/tab_contents/tab_contents.h"
+#include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/web_contents.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace keys = extension_tabs_module_constants;
 namespace errors = extension_manifest_errors;
 
 using content::NavigationEntry;
@@ skipping 652 matching lines @@
   }
   if (!browser)
     return false;
 
   TabStripModel* tab_strip = browser->tabstrip_model();
   TabContentsWrapper* contents = tab_strip->GetActiveTabContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
-  result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+  result_.reset(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
       tab_strip,
       tab_strip->active_index()));
   return true;
 }
 
 bool GetAllTabsInWindowFunction::RunImpl() {
   Browser* browser;
   // windowId defaults to "current" window.
   int window_id = -1;
   if (HasOptionalArgument(0)) {
@@ skipping 64 matching lines @@
 
     if (window_id >= 0 && window_id != ExtensionTabUtil::GetWindowId(*browser))
       continue;
 
     if (!window_type.empty() &&
         window_type != ExtensionTabUtil::GetWindowTypeText(*browser))
       continue;
 
     TabStripModel* tab_strip = (*browser)->tabstrip_model();
     for (int i = 0; i < tab_strip->count(); ++i) {
-      const TabContents* tab_contents =
-          tab_strip->GetTabContentsAt(i)->tab_contents();
+      const WebContents* web_contents =
+          tab_strip->GetTabContentsAt(i)->web_contents();
 
       if (!MatchesQueryArg(selected, tab_strip->IsTabSelected(i)))
         continue;
 
       if (!MatchesQueryArg(active, i == tab_strip->active_index()))
         continue;
 
       if (!MatchesQueryArg(pinned, tab_strip->IsTabPinned(i)))
         continue;
 
-      if (!title.empty() && !MatchPattern(tab_contents->GetTitle(),
+      if (!title.empty() && !MatchPattern(web_contents->GetTitle(),
                                           UTF8ToUTF16(title)))
         continue;
 
-      if (!url_pattern.MatchesURL(tab_contents->GetURL()))
+      if (!url_pattern.MatchesURL(web_contents->GetURL()))
         continue;
 
-      if (!MatchesQueryArg(loading, tab_contents->IsLoading()))
+      if (!MatchesQueryArg(loading, web_contents->IsLoading()))
         continue;
 
       result->Append(ExtensionTabUtil::CreateTabValue(
-          tab_contents, tab_strip, i));
+          web_contents, tab_strip, i));
     }
   }
 
   result_.reset(result);
   return true;
 }
 
 bool CreateTabFunction::RunImpl() {
   DictionaryValue* args = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
@@ skipping 84 matching lines @@
   add_types |= TabStripModel::ADD_FORCE_INDEX;
   if (pinned)
     add_types |= TabStripModel::ADD_PINNED;
   browser::NavigateParams params(browser, url, content::PAGE_TRANSITION_LINK);
   params.disposition = active ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   params.tabstrip_index = index;
   params.tabstrip_add_types = add_types;
   browser::Navigate(&params);
 
   if (active)
-    params.target_contents->tab_contents()->GetView()->SetInitialFocus();
+    params.target_contents->web_contents()->GetView()->SetInitialFocus();
 
   // Return data about the newly created tab.
   if (has_callback()) {
     result_.reset(ExtensionTabUtil::CreateTabValue(
-        params.target_contents->tab_contents(),
+        params.target_contents->web_contents(),
         params.browser->tabstrip_model(),
         params.browser->tabstrip_model()->GetIndexOfTabContents(
             params.target_contents)));
   }
 
   return true;
 }
 
 bool GetTabFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
   TabContentsWrapper* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_))
     return false;
 
-  result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+  result_.reset(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
       tab_strip,
       tab_index));
   return true;
 }
 
 bool GetCurrentTabFunction::RunImpl() {
   DCHECK(dispatcher());
 
   WebContents* contents = dispatcher()->delegate()->GetAssociatedWebContents();
   if (contents)
@@ skipping 78 matching lines @@
     Browser* browser = GetCurrentBrowser();
     if (!browser) {
       error_ = keys::kNoCurrentWindowError;
       return false;
     }
     contents = browser->tabstrip_model()->GetActiveTabContents();
     if (!contents) {
       error_ = keys::kNoSelectedTabError;
       return false;
     }
-    tab_id = ExtensionTabUtil::GetTabId(contents->tab_contents());
+    tab_id = ExtensionTabUtil::GetTabId(contents->web_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;
   }
-  NavigationController& controller = contents->tab_contents()->GetController();
+  NavigationController& controller = contents->web_contents()->GetController();
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
 
   // Navigate the tab to a new location if the url is different.
   std::string url_string;
   if (update_props->HasKey(keys::kUrlKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetString(
         keys::kUrlKey, &url_string));
     GURL url = ResolvePossiblyRelativeURL(url_string, GetExtension());
 
     if (!url.is_valid()) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
                                                        url_string);
       return false;
     }
 
     // Don't let the extension crash the browser or renderers.
     if (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(
-              contents->tab_contents()->GetURL(), NULL, &error_)) {
+              contents->web_contents()->GetURL(), NULL, &error_)) {
         return false;
       }
 
       ExtensionMsg_ExecuteCode_Params params;
       params.request_id = request_id();
       params.extension_id = extension_id();
       params.is_javascript = true;
       params.code = url.path();
       params.all_frames = false;
       params.in_main_world = true;
 
       RenderViewHost* render_view_host =
-          contents->tab_contents()->GetRenderViewHost();
+          contents->web_contents()->GetRenderViewHost();
       render_view_host->Send(
           new ExtensionMsg_ExecuteCode(render_view_host->routing_id(),
                                        params));
 
-      Observe(contents->tab_contents());
+      Observe(contents->web_contents());
       AddRef();  // balanced in Observe()
 
       return true;
     }
 
     controller.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(), contents->tab_contents()->GetURL().spec());
+      DCHECK_EQ(url.spec(), contents->web_contents()->GetURL().spec());
   }
 
   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());
     }
-    contents->tab_contents()->Focus();
+    contents->web_contents()->Focus();
   }
 
   bool highlighted = false;
   if (update_props->HasKey(keys::kHighlightedKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kHighlightedKey, &highlighted));
     if (highlighted != tab_strip->IsTabSelected(tab_index))
       tab_strip->ToggleSelectionAt(tab_index);
   }
 
   bool pinned = false;
   if (update_props->HasKey(keys::kPinnedKey)) {
     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);
   }
 
   if (has_callback()) {
     if (GetExtension()->HasAPIPermission(ExtensionAPIPermission::kTab)) {
-      result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+      result_.reset(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
                                                      tab_strip,
                                                      tab_index));
     } else {
       result_.reset(Value::CreateNullValue());
     }
   }
 
   SendResponse(true);
   return true;
 }
@@ skipping 107 matching lines @@
         // Clamp move location to the last position.
         // This is ">" because it can append to a new index position.
         if (new_index > target_tab_strip->count())
           new_index = target_tab_strip->count();
 
         target_tab_strip->InsertTabContentsAt(
             new_index, contents, TabStripModel::ADD_NONE);
 
         if (has_callback())
           tab_values.Append(ExtensionTabUtil::CreateTabValue(
-              contents->tab_contents(), target_tab_strip, new_index));
+              contents->web_contents(), target_tab_strip, new_index));
 
         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.
     if (new_index >= source_tab_strip->count())
       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->tab_contents(), source_tab_strip, new_index));
+          contents->web_contents(), source_tab_strip, new_index));
   }
 
   if (!has_callback())
     return true;
 
   // Only return the results as an array if there are multiple tabs.
   if (tab_ids.size() > 1) {
     result_.reset(tab_values.DeepCopy());
   } else if (tab_ids.size() == 1) {
     Value* value = NULL;
@@ skipping 36 matching lines @@
   } 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_))
     return false;
   }
 
-  TabContents* tab_contents = contents->tab_contents();
-  if (tab_contents->ShowingInterstitialPage()) {
+  WebContents* web_contents = contents->web_contents();
+  if (web_contents->ShowingInterstitialPage()) {
     // This does as same as Browser::ReloadInternal.
-    NavigationEntry* entry = tab_contents->GetController().GetActiveEntry();
+    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) {
-    tab_contents->GetController().ReloadIgnoringCache(true);
+    web_contents->GetController().ReloadIgnoringCache(true);
   } else {
-    tab_contents->GetController().Reload(true);
+    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;
@@ skipping 10 matching lines @@
     if (!browser->IsTabStripEditable()) {
       error_ = keys::kTabStripNotEditableError;
       return false;
     }
 
     // Close the tab in this convoluted way, since there's a chance that the tab
     // is being dragged, or we're in some other nested event loop. This code
     // path should ensure that the tab is safely closed under such
     // circumstances, whereas |Browser::CloseTabContents()| does not.
     RenderViewHost* render_view_host =
-        contents->tab_contents()->GetRenderViewHost();
+        contents->web_contents()->GetRenderViewHost();
     render_view_host->delegate()->Close(render_view_host);
   }
   return true;
 }
 
 bool CaptureVisibleTabFunction::RunImpl() {
   Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = -1;
 
@@ skipping 31 matching lines @@
         EXTENSION_FUNCTION_VALIDATE(0);
       }
     }
 
     if (options->HasKey(keys::kQualityKey)) {
       EXTENSION_FUNCTION_VALIDATE(
           options->GetInteger(keys::kQualityKey, &image_quality_));
     }
   }
 
-  TabContents* tab_contents = browser->GetSelectedTabContents();
-  if (!tab_contents) {
+  WebContents* web_contents = browser->GetSelectedWebContents();
+  if (!web_contents) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
 
   // captureVisibleTab() can return an image containing sensitive information
   // that the browser would otherwise protect.  Ensure the extension has
   // permission to do this.
-  if (!GetExtension()->CanCaptureVisiblePage(tab_contents->GetURL(), &error_))
+  if (!GetExtension()->CanCaptureVisiblePage(web_contents->GetURL(), &error_))
     return false;
 
-  RenderViewHost* render_view_host = tab_contents->GetRenderViewHost();
+  RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
 
   // If a backing store is cached for the tab we want to capture,
   // and it can be copied into a bitmap, then use it to generate the image.
   BackingStore* backing_store = render_view_host->GetBackingStore(false);
   if (backing_store && CaptureSnapshotFromBackingStore(backing_store))
     return true;
 
   // Ask the renderer for a snapshot of the tab.
   TabContentsWrapper* wrapper = browser->GetSelectedTabContentsWrapper();
   wrapper->snapshot_tab_helper()->CaptureSnapshot();
@@ skipping 113 matching lines @@
       return false;
   } else {
     browser = GetCurrentBrowser();
     if (!browser)
       return false;
     contents = browser->tabstrip_model()->GetActiveTabContents();
     if (!contents)
       return false;
   }
 
-  if (contents->tab_contents()->GetController().NeedsReload()) {
+  if (contents->web_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()
 
   TranslateTabHelper* helper = contents->translate_tab_helper();
   if (!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,
         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->tab_contents()));
+                 content::Source<WebContents>(contents->web_contents()));
   registrar_.Add(
       this, content::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(
-          &(contents->tab_contents()->GetController())));
+          &(contents->web_contents()->GetController())));
   registrar_.Add(
       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(
-          &(contents->tab_contents()->GetController())));
+          &(contents->web_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) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }