TabContentsWrapper -> TabContents, part 12.

chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_api.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/offscreen_tabs/offscreen_tabs_api.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/hash_tables.h"
 #include "base/json/json_writer.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/offscreen_tabs/offscreen_tabs_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_event_names.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/common/chrome_notification_types.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/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 20 matching lines @@
 class OffscreenTab : public content::NotificationObserver {
  public:
   OffscreenTab();
   virtual ~OffscreenTab();
   void Init(const GURL& url,
             const int width,
             const int height,
             Profile* profile,
             ParentTab* parent_tab);
 
-  TabContentsWrapper* tab_contents() const {
-    return tab_contents_wrapper_.get();
+  TabContents* tab_contents() const {
+    return tab_contents_.get();
   }
   WebContents* web_contents() const {
     return tab_contents()->web_contents();
   }
   int GetID() const { return ExtensionTabUtil::GetTabId(web_contents()); }
   ParentTab* parent_tab() { return parent_tab_; }
 
   // Creates a representation of this OffscreenTab for use by the API methods.
   // Passes ownership to the caller.
   DictionaryValue* CreateValue() const;
 
   // Navigates the tab to the |url|.
   void NavigateToURL(const GURL& url) {
     web_contents()->GetController().LoadURL(
         url, content::Referrer(), content::PAGE_TRANSITION_LINK, std::string());
   }
 
   // Adjusts the tab's dimensions to the specified |width| and |height|.
   void SetSize(int width, int height) {
     // TODO(jstritar): this doesn't seem to work on ChromeOS.
     web_contents()->GetView()->SizeContents(gfx::Size(width, height));
   }
 
  private:
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   content::NotificationRegistrar registrar_;
-  scoped_ptr<TabContentsWrapper> tab_contents_wrapper_;
+  scoped_ptr<TabContents> tab_contents_;
   ParentTab* parent_tab_;
 
   DISALLOW_COPY_AND_ASSIGN(OffscreenTab);
 };
 
 typedef ScopedVector<OffscreenTab> OffscreenTabs;
 
 // Holds info about a tab that has spawned at least one offscreen tab.
 // Each ParentTab keeps track of its child offscreen tabs. The ParentTab is also
 // responsible for killing its children when it navigates away or gets closed.
 class ParentTab : public content::NotificationObserver {
  public:
   ParentTab();
   virtual ~ParentTab();
   void Init(WebContents* web_contents,
             const std::string& extension_id);
 
-  TabContentsWrapper* tab_contents() { return tab_contents_wrapper_; }
+  TabContents* tab_contents() { return tab_contents_; }
   int GetID() { return ExtensionTabUtil::GetTabId(web_contents()); }
   WebContents* web_contents() {
     return tab_contents()->web_contents();
   }
 
   // Returns the offscreen tabs spawned by this tab.
   const OffscreenTabs& offscreen_tabs() { return offscreen_tabs_; }
   const std::string& extension_id() const { return extension_id_; }
 
   // Tab takes ownership of OffscreenTab.
   void AddOffscreenTab(OffscreenTab *tab);
 
   // Removes the offscreen |tab| and returns true if this parent has no more
   // offscreen tabs.
   bool RemoveOffscreenTab(OffscreenTab *tab);
 
  private:
   virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) OVERRIDE;
 
   content::NotificationRegistrar registrar_;
 
-  TabContentsWrapper* tab_contents_wrapper_;
+  TabContents* tab_contents_;
   OffscreenTabs offscreen_tabs_;
   std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ParentTab);
 };
 
 // This map keeps track of all tabs that are happy parents of offscreen tabs.
 class OffscreenTabMap {
  public:
   OffscreenTabMap();
@@ skipping 67 matching lines @@
 OffscreenTab::~OffscreenTab() {}
 
 void OffscreenTab::Init(const GURL& url,
                         const int width,
                         const int height,
                         Profile* profile,
                         ParentTab* parent_tab) {
   // Create the offscreen tab.
   WebContents* web_contents = WebContents::Create(
       profile, NULL, MSG_ROUTING_NONE, NULL, NULL);
-  tab_contents_wrapper_.reset(new TabContentsWrapper(web_contents));
+  tab_contents_.reset(new TabContents(web_contents));
 
   // Setting the size starts the renderer.
   SetSize(width, height);
   NavigateToURL(url);
 
   parent_tab_ = parent_tab;
 
   // Register for tab notifications.
   registrar_.Add(
       this,
@@ skipping 30 matching lines @@
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
   // The event router only dispatches the event to renderers listening for the
   // event.
   Profile* profile = parent_tab_->tab_contents()->profile();
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       events::kOnOffscreenTabUpdated, json_args, profile, GURL());
 }
 
-ParentTab::ParentTab() : tab_contents_wrapper_(NULL) {}
+ParentTab::ParentTab() : tab_contents_(NULL) {}
 ParentTab::~ParentTab() {}
 
 void ParentTab::Init(WebContents* web_contents,
                      const std::string& extension_id) {
   CHECK(web_contents);
 
   extension_id_ = extension_id;
-  tab_contents_wrapper_ =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
+  tab_contents_ = TabContents::FromWebContents(web_contents);
 
-  CHECK(tab_contents_wrapper_);
+  CHECK(tab_contents_);
 
   // Register for tab notifications.
   registrar_.Add(
       this,
       content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(&(web_contents->GetController())));
   registrar_.Add(
       this,
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<WebContents>(web_contents));
@@ skipping 457 matching lines @@
     }
   }
 
   return true;
 }
 
 ToDataUrlOffscreenTabFunction::ToDataUrlOffscreenTabFunction() {}
 ToDataUrlOffscreenTabFunction::~ToDataUrlOffscreenTabFunction() {}
 
 bool ToDataUrlOffscreenTabFunction::GetTabToCapture(
-    WebContents** web_contents, TabContentsWrapper** wrapper) {
+    WebContents** web_contents, TabContents** tab_contents) {
   int offscreen_tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
 
   // TODO(alexbost): We want to optimize this function in order to get more
   // image updates on the browser side. One improvement would be to implement
   // another hash map in order to get offscreen tabs in O(1).
   OffscreenTab* offscreen_tab = NULL;
   if (!GetMap()->GetOffscreenTab(
           offscreen_tab_id, this, &offscreen_tab, &error_))
     return false;
 
   *web_contents = offscreen_tab->web_contents();
-  *wrapper = offscreen_tab->tab_contents();
+  *tab_contents = offscreen_tab->tab_contents();
   return true;
 }
 
 UpdateOffscreenTabFunction::UpdateOffscreenTabFunction() {}
 UpdateOffscreenTabFunction::~UpdateOffscreenTabFunction() {}
 
 bool UpdateOffscreenTabFunction::RunImpl() {
   int offscreen_tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &offscreen_tab_id));
 
@@ skipping 37 matching lines @@
   // async case (when a "javascript": URL is sent to a tab).
   if (!is_async)
     SendResponse(true);
 
   return true;
 }
 
 void UpdateOffscreenTabFunction::PopulateResult() {
   // There's no result associated with this callback.
 }