TabContentsWrapper -> TabContents, part 12.

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 23 matching lines @@
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/snapshot_tab_helper.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/windows.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
@@ skipping 119 matching lines @@
   }
   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,
-                TabContentsWrapper** contents,
+                TabContents** 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 189 matching lines @@
       *is_error = true;
       return false;
     }
   }
   return incognito;
 }
 
 bool CreateWindowFunction::RunImpl() {
   DictionaryValue* args = NULL;
   std::vector<GURL> urls;
-  TabContentsWrapper* contents = NULL;
+  TabContents* contents = NULL;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   // Look for optional url.
   if (args) {
     if (args->HasKey(keys::kUrlKey)) {
       Value* url_value;
       std::vector<std::string> url_strings;
       args->Get(keys::kUrlKey, &url_value);
@@ skipping 193 matching lines @@
         web_app::GenerateApplicationNameFromExtensionId(extension_id),
         (window_type == Browser::TYPE_PANEL ? panel_bounds : popup_bounds),
         window_profile);
   }
   create_params.initial_show_state = ui::SHOW_STATE_NORMAL;
 
   Browser* new_window = CreateBrowserWindow(create_params, window_profile,
                                             extension_id);
 
   for (std::vector<GURL>::iterator i = urls.begin(); i != urls.end(); ++i) {
-    TabContentsWrapper* tab = new_window->AddSelectedTabWithURL(
+    TabContents* tab = new_window->AddSelectedTabWithURL(
         *i, content::PAGE_TRANSITION_LINK);
     if (window_type == Browser::TYPE_PANEL)
       tab->extension_tab_helper()->SetExtensionAppIconById(extension_id);
   }
   if (contents) {
     TabStripModel* target_tab_strip = new_window->tab_strip_model();
     target_tab_strip->InsertTabContentsAt(urls.size(), contents,
                                           TabStripModel::ADD_NONE);
   } else if (urls.empty()) {
     new_window->NewTab();
@@ skipping 181 matching lines @@
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   Browser* browser = NULL;
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   TabStripModel* tab_strip = browser->tab_strip_model();
-  TabContentsWrapper* contents = tab_strip->GetActiveTabContents();
+  TabContents* contents = tab_strip->GetActiveTabContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
   result_.reset(ExtensionTabUtil::CreateTabValue(contents->web_contents(),
       tab_strip,
       tab_strip->active_index()));
   return true;
 }
 
@@ skipping 149 matching lines @@
     return false;
 
   // TODO(jstritar): Add a constant, chrome.tabs.TAB_ID_ACTIVE, that
   // represents the active tab.
   content::NavigationController* opener = NULL;
   if (args->HasKey(keys::kOpenerTabIdKey)) {
     int opener_id = -1;
     EXTENSION_FUNCTION_VALIDATE(args->GetInteger(
         keys::kOpenerTabIdKey, &opener_id));
 
-    TabContentsWrapper* opener_contents = NULL;
+    TabContents* opener_contents = NULL;
     if (!ExtensionTabUtil::GetTabById(
             opener_id, profile(), include_incognito(),
             NULL, NULL, &opener_contents, NULL))
       return false;
 
     opener = &opener_contents->web_contents()->GetController();
   }
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
@@ skipping 90 matching lines @@
   }
 
   return true;
 }
 
 bool GetTabFunction::RunImpl() {
   int tab_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
-  TabContentsWrapper* contents = NULL;
+  TabContents* 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->web_contents(),
       tab_strip,
       tab_index));
   return true;
 }
@@ skipping 70 matching lines @@
 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;
-  TabContentsWrapper* contents = NULL;
+  TabContents* 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();
     if (!contents) {
       error_ = keys::kNoSelectedTabError;
       return false;
@@ skipping 57 matching lines @@
 
     // Update the tab index because it may move when being pinned.
     tab_index = tab_strip->GetIndexOfTabContents(contents);
   }
 
   if (update_props->HasKey(keys::kOpenerTabIdKey)) {
     int opener_id = -1;
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kOpenerTabIdKey, &opener_id));
 
-    TabContentsWrapper* opener_contents = NULL;
+    TabContents* opener_contents = NULL;
     if (!ExtensionTabUtil::GetTabById(
             opener_id, profile(), include_incognito(),
             NULL, NULL, &opener_contents, NULL))
       return false;
 
     tab_strip->SetOpenerOfTabContentsAt(
         tab_index, &opener_contents->web_contents()->GetController());
   }
 
   if (!is_async) {
@@ skipping 94 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;
-    TabContentsWrapper* contents = NULL;
+    TabContents* 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 (!source_browser->IsTabStripEditable()) {
       error_ = keys::kTabStripNotEditableError;
       return false;
@@ skipping 89 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));
       }
   }
 
-  TabContentsWrapper* contents = NULL;
+  TabContents* 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) {
@@ skipping 32 matching lines @@
 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;
-    TabContentsWrapper* contents = NULL;
+    TabContents* 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 (!browser->IsTabStripEditable()) {
       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 |Browser::CloseTabContents()| does not.
     contents->web_contents()->Close();
   }
   return true;
 }
 
 bool CaptureVisibleTabFunction::GetTabToCapture(
-    WebContents** web_contents, TabContentsWrapper** wrapper) {
+    WebContents** web_contents, TabContents** tab_contents) {
   Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
-  *web_contents = browser->GetSelectedWebContents();
+  *web_contents = browser->GetActiveWebContents();
   if (*web_contents == NULL) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
 
-  *wrapper = browser->GetSelectedTabContentsWrapper();
+  *tab_contents = browser->GetActiveTabContents();
 
   return true;
 };
 
 bool CaptureVisibleTabFunction::RunImpl() {
   WebContents* web_contents = NULL;
-  TabContentsWrapper* wrapper = NULL;
-  if (!GetTabToCapture(&web_contents, &wrapper))
+  TabContents* tab_contents = NULL;
+  if (!GetTabToCapture(&web_contents, &tab_contents))
     return false;
 
   image_format_ = FORMAT_JPEG;  // Default format is JPEG.
   image_quality_ = kDefaultQuality;  // Default quality setting.
 
   if (HasOptionalArgument(1)) {
     DictionaryValue* options = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
 
     if (options->HasKey(keys::kFormatKey)) {
@@ skipping 43 matching lines @@
 void CaptureVisibleTabFunction::CopyFromBackingStoreComplete(
     skia::PlatformCanvas* canvas,
     bool succeeded) {
   if (succeeded) {
     VLOG(1) << "captureVisibleTab() got image from backing store.";
     SendResultFromBitmap(skia::GetTopDevice(*canvas)->accessBitmap(false));
     return;
   }
 
   WebContents* web_contents = NULL;
-  TabContentsWrapper* wrapper = NULL;
-  if (!GetTabToCapture(&web_contents, &wrapper)) {
+  TabContents* tab_contents = NULL;
+  if (!GetTabToCapture(&web_contents, &tab_contents)) {
     error_ = keys::kInternalVisibleTabCaptureError;
     SendResponse(false);
     return;
   }
 
   // Ask the renderer for a snapshot of the tab.
   registrar_.Add(this,
                  chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
                  content::Source<WebContents>(web_contents));
   AddRef();  // Balanced in CaptureVisibleTabFunction::Observe().
-  wrapper->snapshot_tab_helper()->CaptureSnapshot();
+  tab_contents->snapshot_tab_helper()->CaptureSnapshot();
 }
 
 // If a backing store was not available in CaptureVisibleTabFunction::RunImpl,
 // than the renderer was asked for a snapshot.  Listen for a notification
 // that the snapshot is available.
 void CaptureVisibleTabFunction::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN);
@@ skipping 57 matching lines @@
   base::Base64Encode(stream_as_string, &base64_result);
   base64_result.insert(0, base::StringPrintf("data:%s;base64,",
                                              mime_type.c_str()));
   result_.reset(new StringValue(base64_result));
   SendResponse(true);
 }
 
 bool DetectTabLanguageFunction::RunImpl() {
   int tab_id = 0;
   Browser* browser = NULL;
-  TabContentsWrapper* contents = NULL;
+  TabContents* 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)
@@ skipping 53 matching lines @@
   // 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()
 }