Make pink's TabContentsWrapper change compile on Windows....

chrome/browser/extensions/extension_tabs_module.cc

 // Copyright (c) 2010 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 "base/base64.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_infobar_delegate.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_delegate.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/url_constants.h"
 #include "gfx/codec/jpeg_codec.h"
 #include "gfx/codec/png_codec.h"
 #include "skia/ext/image_operations.h"
@@ skipping 12 matching lines @@
                                           const int window_id,
                                           bool include_incognito,
                                           std::string* error_message);
 
 // |error_message| can optionally be passed in and will be set with an
 // appropriate message if the tab cannot be found by id.
 static bool GetTabById(int tab_id, Profile* profile,
                        bool include_incognito,
                        Browser** browser,
                        TabStripModel** tab_strip,
-                       TabContents** contents,
+                       TabContentsWrapper** contents,
                        int* tab_index, std::string* error_message);
 
 // Takes |url_string| and returns a GURL which is either valid and absolute
 // or invalid. If |url_string| is not directly interpretable as a valid (it is
 // likely a relative URL) an attempt is made to resolve it. |extension| is
 // provided so it can be resolved relative to its extension base
 // (chrome-extension://<id>/). Using the source frame url would be more correct,
 // but because the api shipped with urls resolved relative to their extension
 // base, we decided it wasn't worth breaking existing extensions to fix.
 static GURL ResolvePossiblyRelativeURL(std::string url_string,
@@ skipping 28 matching lines @@
 
   // Couldn't find it.  This can happen if the tab is being dragged.
   return ExtensionTabUtil::CreateTabValue(contents, NULL, -1);
 }
 
 ListValue* ExtensionTabUtil::CreateTabList(const Browser* browser) {
   ListValue* tab_list = new ListValue();
   TabStripModel* tab_strip = browser->tabstrip_model();
   for (int i = 0; i < tab_strip->count(); ++i) {
     tab_list->Append(ExtensionTabUtil::CreateTabValue(
-        tab_strip->GetTabContentsAt(i), tab_strip, i));
+        tab_strip->GetTabContentsAt(i)->tab_contents(), tab_strip, i));
   }
 
   return tab_list;
 }
 
 DictionaryValue* ExtensionTabUtil::CreateTabValue(
     const TabContents* contents, TabStripModel* tab_strip, int tab_index) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(keys::kIdKey, ExtensionTabUtil::GetTabId(contents));
   result->SetInteger(keys::kIndexKey, tab_index);
@@ skipping 49 matching lines @@
 bool ExtensionTabUtil::GetTabStripModel(const TabContents* tab_contents,
                                         TabStripModel** tab_strip_model,
                                         int* tab_index) {
   DCHECK(tab_contents);
   DCHECK(tab_strip_model);
   DCHECK(tab_index);
 
   for (BrowserList::const_iterator it = BrowserList::begin();
       it != BrowserList::end(); ++it) {
     TabStripModel* tab_strip = (*it)->tabstrip_model();
-    int index = tab_strip->GetIndexOfTabContents(tab_contents);
+    int index = tab_strip->GetWrapperIndex(tab_contents);
     if (index != -1) {
       *tab_strip_model = tab_strip;
       *tab_index = index;
       return true;
     }
   }
 
   return false;
 }
 
-bool ExtensionTabUtil::GetDefaultTab(Browser* browser, TabContents** contents,
+bool ExtensionTabUtil::GetDefaultTab(Browser* browser,
+                                     TabContentsWrapper** contents,
                                      int* tab_id) {
   DCHECK(browser);
   DCHECK(contents);
   DCHECK(tab_id);
 
-  *contents = browser->tabstrip_model()->GetSelectedTabContents();
+  *contents = browser->GetSelectedTabContentsWrapper();
   if (*contents) {
     if (tab_id)
-      *tab_id = ExtensionTabUtil::GetTabId(*contents);
+      *tab_id = ExtensionTabUtil::GetTabId((*contents)->tab_contents());
     return true;
   }
 
   return false;
 }
 
 bool ExtensionTabUtil::GetTabById(int tab_id, Profile* profile,
                                   bool include_incognito,
                                   Browser** browser,
                                   TabStripModel** tab_strip,
-                                  TabContents** contents,
+                                  TabContentsWrapper** contents,
                                   int* tab_index) {
-  Browser* target_browser;
-  TabStripModel* target_tab_strip;
-  TabContents* target_contents;
   Profile* incognito_profile =
       include_incognito && profile->HasOffTheRecordProfile() ?
           profile->GetOffTheRecordProfile() : NULL;
   for (BrowserList::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end(); ++iter) {
-    target_browser = *iter;
+    Browser* target_browser = *iter;
     if (target_browser->profile() == profile ||
         target_browser->profile() == incognito_profile) {
-      target_tab_strip = target_browser->tabstrip_model();
+      TabStripModel* target_tab_strip = target_browser->tabstrip_model();
       for (int i = 0; i < target_tab_strip->count(); ++i) {
-        target_contents = target_tab_strip->GetTabContentsAt(i);
+        TabContentsWrapper* target_contents =
+            target_tab_strip->GetTabContentsAt(i);
         if (target_contents->controller().session_id().id() == tab_id) {
           if (browser)
             *browser = target_browser;
           if (tab_strip)
             *tab_strip = target_tab_strip;
           if (contents)
             *contents = target_contents;
           if (tab_index)
             *tab_index = i;
           return true;
@@ skipping 301 matching lines @@
                                         include_incognito(), &error_);
   } else {
     browser = GetCurrentBrowser();
     if (!browser)
       error_ = keys::kNoCurrentWindowError;
   }
   if (!browser)
     return false;
 
   TabStripModel* tab_strip = browser->tabstrip_model();
-  TabContents* contents = tab_strip->GetSelectedTabContents();
+  TabContentsWrapper* contents = tab_strip->GetSelectedTabContents();
   if (!contents) {
     error_ = keys::kNoSelectedTabError;
     return false;
   }
-  result_.reset(ExtensionTabUtil::CreateTabValue(contents, tab_strip,
+  result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+      tab_strip,
       tab_strip->selected_index()));
   return true;
 }
 
 bool GetAllTabsInWindowFunction::RunImpl() {
   Browser* browser;
   // windowId defaults to "current" window.
   int window_id = -1;
   if (HasOptionalArgument(0)) {
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
@@ skipping 96 matching lines @@
   params.tabstrip_index = index;
   params.tabstrip_add_types = add_types;
   browser::Navigate(&params);
 
   if (selected)
     params.target_contents->view()->SetInitialFocus();
 
   // Return data about the newly created tab.
   if (has_callback()) {
     result_.reset(ExtensionTabUtil::CreateTabValue(
-        params.target_contents,
+        params.target_contents->tab_contents(),
         params.browser->tabstrip_model(),
         params.browser->tabstrip_model()->GetIndexOfTabContents(
             params.target_contents)));
   }
 
   return true;
 }
 
 bool GetTabFunction::RunImpl() {
   int tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   TabStripModel* tab_strip = NULL;
-  TabContents* contents = 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_strip,
+  result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+      tab_strip,
       tab_index));
   return true;
 }
 
 bool GetCurrentTabFunction::RunImpl() {
   DCHECK(dispatcher());
 
   TabContents* contents = dispatcher()->delegate()->associated_tab_contents();
   if (contents)
     result_.reset(ExtensionTabUtil::CreateTabValue(contents));
 
   return true;
 }
 
 bool UpdateTabFunction::RunImpl() {
   int tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
   DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   TabStripModel* tab_strip = NULL;
-  TabContents* contents = NULL;
+  TabContentsWrapper* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_))
     return false;
 
   NavigationController& controller = contents->controller();
 
   // TODO(rafaelw): handle setting remaining tab properties:
   // -title
   // -favIconUrl
@@ skipping 11 matching lines @@
       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)) {
       const Extension* extension = GetExtension();
       const std::vector<URLPattern> host_permissions =
           extension->host_permissions();
       if (!Extension::CanExecuteScriptOnPage(
-              contents->GetURL(),
+              contents->tab_contents()->GetURL(),
               extension->CanExecuteScriptEverywhere(),
               &host_permissions,
               NULL,
               &error_)) {
         return false;
       }
 
       // TODO(aa): How does controller queue URLs? Is there any chance that this
       // JavaScript URL will end up applying to something other than
       // controller->GetURL()?
     }
 
     controller.LoadURL(url, GURL(), PageTransition::LINK);
 
     // 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->GetURL().spec());
+      DCHECK_EQ(url.spec(), contents->tab_contents()->GetURL().spec());
   }
 
   bool selected = false;
   // TODO(rafaelw): Setting |selected| 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,
         &selected));
     if (selected) {
       if (tab_strip->selected_index() != tab_index) {
         tab_strip->SelectTabContentsAt(tab_index, false);
         DCHECK_EQ(contents, tab_strip->GetSelectedTabContents());
       }
-      contents->Focus();
+      contents->tab_contents()->Focus();
     }
   }
 
   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())
-    result_.reset(ExtensionTabUtil::CreateTabValue(contents, tab_strip,
+    result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+        tab_strip,
         tab_index));
 
   return true;
 }
 
 bool MoveTabFunction::RunImpl() {
   int tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
   DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
   int new_index;
   EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
       keys::kIndexKey, &new_index));
   EXTENSION_FUNCTION_VALIDATE(new_index >= 0);
 
   Browser* source_browser = NULL;
   TabStripModel* source_tab_strip = NULL;
-  TabContents* contents = NULL;
+  TabContentsWrapper* contents = NULL;
   int tab_index = -1;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   &source_browser, &source_tab_strip, &contents,
                   &tab_index, &error_))
     return false;
 
   if (source_browser->type() != Browser::TYPE_NORMAL) {
     error_ = keys::kCanOnlyMoveTabsWithinNormalWindowsError;
     return false;
   }
@@ skipping 26 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())
-        result_.reset(ExtensionTabUtil::CreateTabValue(contents,
+        result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
             target_tab_strip, new_index));
 
       return true;
     }
   }
 
   // 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())
-    result_.reset(ExtensionTabUtil::CreateTabValue(contents, source_tab_strip,
+    result_.reset(ExtensionTabUtil::CreateTabValue(contents->tab_contents(),
+        source_tab_strip,
         new_index));
   return true;
 }
 
 
 bool RemoveTabFunction::RunImpl() {
   int tab_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &tab_id));
 
   Browser* browser = NULL;
-  TabContents* contents = NULL;
+  TabContentsWrapper* contents = NULL;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   &browser, NULL, &contents, NULL, &error_))
     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->render_view_host();
   render_view_host->delegate()->Close(render_view_host);
@@ skipping 158 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;
-  TabContents* contents = NULL;
+  TabContentsWrapper* 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->tabstrip_model()->GetSelectedTabContents();
     if (!contents)
       return false;
   }
 
   if (contents->controller().needs_reload()) {
     // If the tab hasn't been loaded, don't wait for the tab to load.
     error_ = keys::kCannotDetermineLanguageOfUnloadedTab;
     return false;
   }
 
   AddRef();  // Balanced in GotLanguage()
 
-  if (!contents->language_state().original_language().empty()) {
+  if (!contents->tab_contents()->language_state().original_language().empty()) {
     // Delay the callback invocation until after the current JS call has
     // returned.
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &DetectTabLanguageFunction::GotLanguage,
-        contents->language_state().original_language()));
+        contents->tab_contents()->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, NotificationType::TAB_LANGUAGE_DETERMINED,
-                 Source<TabContents>(contents));
+                 Source<TabContents>(contents->tab_contents()));
   registrar_.Add(this, NotificationType::TAB_CLOSING,
                  Source<NavigationController>(&(contents->controller())));
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(&(contents->controller())));
   return true;
 }
 
 void DetectTabLanguageFunction::Observe(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
@@ skipping 36 matching lines @@
     *error_message = ExtensionErrorUtils::FormatErrorMessage(
         keys::kWindowNotFoundError, base::IntToString(window_id));
 
   return NULL;
 }
 
 static bool GetTabById(int tab_id, Profile* profile,
                        bool include_incognito,
                        Browser** browser,
                        TabStripModel** tab_strip,
-                       TabContents** contents,
+                       TabContentsWrapper** 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 12 matching lines @@
 }
 
 static GURL ResolvePossiblyRelativeURL(std::string url_string,
                                        const Extension* extension) {
   GURL url = GURL(url_string);
   if (!url.is_valid())
     url = extension->GetResourceURL(url_string);
 
   return url;
 }