TabContentsWrapper -> TabContents, part 42.

chrome/browser/ui/intents/web_intent_picker_controller.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/ui/intents/web_intent_picker_controller.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/webstore_installer.h"
 #include "chrome/browser/favicon/favicon_service.h"
 #include "chrome/browser/intents/cws_intents_registry_factory.h"
 #include "chrome/browser/intents/default_web_intent_service.h"
 #include "chrome/browser/intents/web_intents_registry_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.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/intents/web_intent_picker.h"
 #include "chrome/browser/ui/intents/web_intent_picker_model.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/webdata/web_data_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_intents_dispatcher.h"
 #include "content/public/common/url_fetcher.h"
@@ skipping 10 matching lines @@
 namespace {
 
 const char kShareActionURL[] = "http://webintents.org/share";
 const char kEditActionURL[] = "http://webintents.org/edit";
 const char kViewActionURL[] = "http://webintents.org/view";
 const char kPickActionURL[] = "http://webintents.org/pick";
 const char kSubscribeActionURL[] = "http://webintents.org/subscribe";
 const char kSaveActionURL[] = "http://webintents.org/save";
 
 // Gets the favicon service for the profile in |tab_contents|.
-FaviconService* GetFaviconService(TabContentsWrapper* wrapper) {
-  return wrapper->profile()->GetFaviconService(Profile::EXPLICIT_ACCESS);
+FaviconService* GetFaviconService(TabContents* tab_contents) {
+  return tab_contents->profile()->GetFaviconService(Profile::EXPLICIT_ACCESS);
 }
 
 // Gets the web intents registry for the profile in |tab_contents|.
-WebIntentsRegistry* GetWebIntentsRegistry(TabContentsWrapper* wrapper) {
-  return WebIntentsRegistryFactory::GetForProfile(wrapper->profile());
+WebIntentsRegistry* GetWebIntentsRegistry(TabContents* tab_contents) {
+  return WebIntentsRegistryFactory::GetForProfile(tab_contents->profile());
 }
 
 // Gets the Chrome web store intents registry for the profile in |tab_contents|.
-CWSIntentsRegistry* GetCWSIntentsRegistry(TabContentsWrapper* wrapper) {
-  return CWSIntentsRegistryFactory::GetForProfile(wrapper->profile());
+CWSIntentsRegistry* GetCWSIntentsRegistry(TabContents* tab_contents) {
+  return CWSIntentsRegistryFactory::GetForProfile(tab_contents->profile());
 }
 
 WebIntentPickerModel::Disposition ConvertDisposition(
     webkit_glue::WebIntentServiceData::Disposition disposition) {
   switch (disposition) {
     case webkit_glue::WebIntentServiceData::DISPOSITION_INLINE:
       return WebIntentPickerModel::DISPOSITION_INLINE;
     case webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW:
       return WebIntentPickerModel::DISPOSITION_WINDOW;
     default:
@@ skipping 48 matching lines @@
     const net::URLFetcher* source) {
   DCHECK(!callback_.is_null());
   callback_.Run(source);
   delete source;
   delete this;
 }
 
 }  // namespace
 
 WebIntentPickerController::WebIntentPickerController(
-    TabContentsWrapper* wrapper)
-    : wrapper_(wrapper),
+    TabContents* tab_contents)
+    : tab_contents_(tab_contents),
       picker_(NULL),
       picker_model_(new WebIntentPickerModel()),
       pending_async_count_(0),
       pending_registry_calls_count_(0),
       picker_shown_(false),
       intents_dispatcher_(NULL),
       service_tab_(NULL),
       weak_ptr_factory_(this) {
   content::NavigationController* controller =
-      &wrapper->web_contents()->GetController();
+      &tab_contents->web_contents()->GetController();
   registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                  content::Source<content::NavigationController>(controller));
   registrar_.Add(this, chrome::NOTIFICATION_TAB_CLOSING,
                  content::Source<content::NavigationController>(controller));
 }
 
 WebIntentPickerController::~WebIntentPickerController() {
 }
 
 // TODO(gbillock): combine this with ShowDialog.
@@ skipping 15 matching lines @@
     if (intents_dispatcher_) {
       intents_dispatcher_->SendReplyMessage(
           webkit_glue::WEB_INTENT_REPLY_FAILURE,
           ASCIIToUTF16("Simultaneous intent invocation."));
     }
     return;
   }
 
   // TODO(binji): Figure out what to do when intents are invoked from incognito
   // mode.
-  if (wrapper_->profile()->IsOffTheRecord()) {
+  if (tab_contents_->profile()->IsOffTheRecord()) {
     if (intents_dispatcher_) {
       intents_dispatcher_->SendReplyMessage(
           webkit_glue::WEB_INTENT_REPLY_FAILURE, string16());
     }
     return;
   }
 
   picker_model_->Clear();
   picker_model_->set_action(action);
   picker_model_->set_mimetype(type);
 
   // If the intent is explicit, skip showing the picker.
   if (intents_dispatcher_) {
     const GURL& service = intents_dispatcher_->GetIntent().service;
     if (service.is_valid()) {
       // TODO(gbillock): When we can parse pages for the intent tag,
       // take out this requirement that explicit intents dispatch to
       // extension urls.
       if (!service.SchemeIs(chrome::kExtensionScheme)) {
         intents_dispatcher_->SendReplyMessage(
             webkit_glue::WEB_INTENT_REPLY_FAILURE, ASCIIToUTF16(
                 "Only extension urls are supported for explicit invocation"));
         return;
       }
 
       // Get services from the registry to verify a registered extension
       // page for this action/type if it is permitted to be dispatched. (Also
       // required to find disposition set by service.)
       pending_async_count_++;
-      GetWebIntentsRegistry(wrapper_)->GetIntentServices(
+      GetWebIntentsRegistry(tab_contents_)->GetIntentServices(
           action, type, base::Bind(
               &WebIntentPickerController::WebIntentServicesForExplicitIntent,
               weak_ptr_factory_.GetWeakPtr()));
       return;
     }
   }
 
   pending_async_count_ += 2;
   pending_registry_calls_count_ += 1;
 
-  GetWebIntentsRegistry(wrapper_)->GetIntentServices(
+  GetWebIntentsRegistry(tab_contents_)->GetIntentServices(
       action, type,
           base::Bind(&WebIntentPickerController::OnWebIntentServicesAvailable,
               weak_ptr_factory_.GetWeakPtr()));
 
-  GURL invoking_url = wrapper_->web_contents()->GetURL();
+  GURL invoking_url = tab_contents_->web_contents()->GetURL();
   if (invoking_url.is_valid()) {
     pending_async_count_++;
     pending_registry_calls_count_++;
-    GetWebIntentsRegistry(wrapper_)->GetDefaultIntentService(
+    GetWebIntentsRegistry(tab_contents_)->GetDefaultIntentService(
         action, type, invoking_url,
         base::Bind(&WebIntentPickerController::OnWebIntentDefaultsAvailable,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  GetCWSIntentsRegistry(wrapper_)->GetIntentServices(
+  GetCWSIntentsRegistry(tab_contents_)->GetIntentServices(
       action, type,
       base::Bind(&WebIntentPickerController::OnCWSIntentServicesAvailable,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebIntentPickerController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_LOAD_START ||
          type == chrome::NOTIFICATION_TAB_CLOSING);
   ClosePicker();
 }
 
 void WebIntentPickerController::OnServiceChosen(const GURL& url,
                                                 Disposition disposition) {
   switch (disposition) {
     case WebIntentPickerModel::DISPOSITION_INLINE:
       // Set the model to inline disposition. It will notify the picker which
       // will respond (via OnInlineDispositionWebContentsCreated) with the
       // WebContents to dispatch the intent to.
       picker_model_->SetInlineDisposition(url);
       break;
 
     case WebIntentPickerModel::DISPOSITION_WINDOW: {
       int index = TabStripModel::kNoTab;
       Browser* browser = browser::FindBrowserForController(
-          &wrapper_->web_contents()->GetController(), &index);
-      TabContentsWrapper* contents = Browser::TabContentsFactory(
-          wrapper_->profile(),
+          &tab_contents_->web_contents()->GetController(), &index);
+      TabContents* contents = Browser::TabContentsFactory(
+          tab_contents_->profile(),
           tab_util::GetSiteInstanceForNewTab(
-              wrapper_->profile(), url),
+              tab_contents_->profile(), url),
           MSG_ROUTING_NONE, NULL, NULL);
 
       intents_dispatcher_->DispatchIntent(contents->web_contents());
       service_tab_ = contents->web_contents();
 
       // This call performs all the tab strip manipulation, notifications, etc.
       // Since we're passing in a target_contents, it assumes that we will
       // navigate the page ourselves, though.
       browser::NavigateParams params(browser,
                                      url,
                                      content::PAGE_TRANSITION_AUTO_BOOKMARK);
       params.target_contents = contents;
       params.disposition = NEW_FOREGROUND_TAB;
-      params.profile = wrapper_->profile();
+      params.profile = tab_contents_->profile();
       browser::Navigate(&params);
 
       service_tab_->GetController().LoadURL(
           url, content::Referrer(),
           content::PAGE_TRANSITION_AUTO_BOOKMARK, std::string());
 
       ClosePicker();
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 void WebIntentPickerController::OnInlineDispositionWebContentsCreated(
     content::WebContents* web_contents) {
   if (web_contents)
     intents_dispatcher_->DispatchIntent(web_contents);
 }
 
 void WebIntentPickerController::OnExtensionInstallRequested(
     const std::string& id) {
   scoped_ptr<WebstoreInstaller::Approval> approval(
       WebstoreInstaller::Approval::CreateWithInstallPrompt(
-          wrapper_->profile()));
+          tab_contents_->profile()));
 
   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
-      wrapper_->profile(), this, &wrapper_->web_contents()->GetController(), id,
+      tab_contents_->profile(), this,
+      &tab_contents_->web_contents()->GetController(), id,
       approval.Pass(), WebstoreInstaller::FLAG_INLINE_INSTALL);
 
   pending_async_count_++;
   installer->Start();
 }
 
 void WebIntentPickerController::OnExtensionLinkClicked(const std::string& id) {
   // Navigate from source tab.
   Browser* browser =
-      browser::FindBrowserWithWebContents(wrapper_->web_contents());
+      browser::FindBrowserWithWebContents(tab_contents_->web_contents());
   GURL extension_url(extension_urls::GetWebstoreItemDetailURLPrefix() + id);
   browser::NavigateParams params(browser, extension_url,
       content::PAGE_TRANSITION_AUTO_BOOKMARK);
   params.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&params);
 }
 
 void WebIntentPickerController::OnSuggestionsLinkClicked() {
   // Navigate from source tab.
   Browser* browser =
-      browser::FindBrowserWithWebContents(wrapper_->web_contents());
+      browser::FindBrowserWithWebContents(tab_contents_->web_contents());
   GURL query_url = extension_urls::GetWebstoreIntentQueryURL(
       UTF16ToUTF8(picker_model_->action()),
       UTF16ToUTF8(picker_model_->mimetype()));
   browser::NavigateParams params(browser, query_url,
                                  content::PAGE_TRANSITION_AUTO_BOOKMARK);
   params.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&params);
 }
 
 void WebIntentPickerController::OnPickerClosed() {
@@ skipping 20 matching lines @@
 
 void WebIntentPickerController::OnClosing() {
   picker_shown_ = false;
   picker_ = NULL;
 }
 
 void WebIntentPickerController::OnExtensionInstallSuccess(
     const std::string& id) {
   picker_->OnExtensionInstallSuccess(id);
   pending_async_count_++;
-  GetWebIntentsRegistry(wrapper_)->GetIntentServicesForExtensionFilter(
+  GetWebIntentsRegistry(tab_contents_)->GetIntentServicesForExtensionFilter(
       picker_model_->action(),
       picker_model_->mimetype(),
       id,
       base::Bind(
           &WebIntentPickerController::OnExtensionInstallServiceAvailable,
           weak_ptr_factory_.GetWeakPtr()));
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnExtensionInstallFailure(
@@ skipping 11 matching lines @@
       reply_type != webkit_glue::WEB_INTENT_SERVICE_CONTENTS_CLOSED) {
     int index = TabStripModel::kNoTab;
     Browser* browser = browser::FindBrowserForController(
         &service_tab_->GetController(), &index);
     if (browser) {
       browser->tab_strip_model()->CloseTabContentsAt(
           index, TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 
       // Activate source tab.
       Browser* source_browser =
-          browser::FindBrowserWithWebContents(wrapper_->web_contents());
+          browser::FindBrowserWithWebContents(tab_contents_->web_contents());
       if (source_browser) {
-        int source_index =
-            source_browser->tab_strip_model()->GetIndexOfTabContents(wrapper_);
+        int source_index = source_browser->tab_strip_model()->
+            GetIndexOfTabContents(tab_contents_);
         source_browser->ActivateTabAt(source_index, false);
       }
     }
     service_tab_ = NULL;
   }
 
   intents_dispatcher_ = NULL;
 }
 
 void WebIntentPickerController::OnWebIntentServicesAvailable(
     const std::vector<webkit_glue::WebIntentServiceData>& services) {
-  FaviconService* favicon_service = GetFaviconService(wrapper_);
+  FaviconService* favicon_service = GetFaviconService(tab_contents_);
   for (size_t i = 0; i < services.size(); ++i) {
     picker_model_->AddInstalledService(
         services[i].title,
         services[i].service_url,
         ConvertDisposition(services[i].disposition));
 
     pending_async_count_++;
     FaviconService::Handle handle = favicon_service->GetFaviconForURL(
         services[i].service_url,
         history::FAVICON,
@@ skipping 15 matching lines @@
   for (size_t i = 0; i < services.size(); ++i) {
     if (services[i].service_url != intents_dispatcher_->GetIntent().service)
       continue;
 
     picker_model_->AddInstalledService(
         services[i].title,
         services[i].service_url,
         ConvertDisposition(services[i].disposition));
 
     pending_async_count_++;
-    FaviconService* favicon_service = GetFaviconService(wrapper_);
+    FaviconService* favicon_service = GetFaviconService(tab_contents_);
     FaviconService::Handle handle = favicon_service->GetFaviconForURL(
         services[i].service_url,
         history::FAVICON,
         &favicon_consumer_,
         base::Bind(
             &WebIntentPickerController::OnFaviconDataAvailable,
             weak_ptr_factory_.GetWeakPtr()));
     favicon_consumer_.SetClientData(
         favicon_service, handle,
         picker_model_->GetInstalledServiceCount() - 1);
@@ skipping 66 matching lines @@
       return;
     }
   }
 
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnCWSIntentServicesAvailable(
     const CWSIntentsRegistry::IntentExtensionList& extensions) {
   ExtensionServiceInterface* extension_service =
-      wrapper_->profile()->GetExtensionService();
+      tab_contents_->profile()->GetExtensionService();
   for (size_t i = 0; i < extensions.size(); ++i) {
     const CWSIntentsRegistry::IntentExtensionInfo& info = extensions[i];
     if (extension_service->GetExtensionById(UTF16ToUTF8(info.id),
                                             true)) {  // Include disabled.
       continue;
     }
 
     picker_model_->AddSuggestedExtension(
         info.name,
         info.id,
         info.average_rating);
 
     pending_async_count_++;
     net::URLFetcher* icon_url_fetcher = content::URLFetcher::Create(
         0,
         info.icon_url,
         net::URLFetcher::GET,
         new URLFetcherTrampoline(
             base::Bind(
                 &WebIntentPickerController::OnExtensionIconURLFetchComplete,
                 weak_ptr_factory_.GetWeakPtr(), info.id)));
 
     icon_url_fetcher->SetLoadFlags(
         net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
     icon_url_fetcher->SetRequestContext(
-        wrapper_->profile()->GetRequestContext());
+        tab_contents_->profile()->GetRequestContext());
     icon_url_fetcher->Start();
   }
 
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnExtensionIconURLFetchComplete(
     const string16& extension_id, const net::URLFetcher* source) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (source->GetResponseCode() != 200) {
@@ skipping 95 matching lines @@
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (--pending_async_count_ == 0) {
     if (picker_)
       picker_->OnPendingAsyncCompleted();
   }
 }
 
 void WebIntentPickerController::CreatePicker() {
   // If picker is non-NULL, it was set by a test.
   if (picker_ == NULL)
-    picker_ = WebIntentPicker::Create(wrapper_, this, picker_model_.get());
+    picker_ = WebIntentPicker::Create(tab_contents_, this, picker_model_.get());
   picker_shown_ = true;
 }
 
 void WebIntentPickerController::ClosePicker() {
   if (picker_)
     picker_->Close();
 }