Switch WebIntentPickerController to use WebContentsUserData.

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"
@@ skipping 39 matching lines @@
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
 
 using extensions::WebstoreInstaller;
 
+int WebIntentPickerController::kUserDataKey;
+
 namespace {
 
 // Maximum amount of time to delay displaying dialog while waiting for data.
 const int kMaxHiddenSetupTimeMs = 200;
 
 // Minimum amount of time to show waiting dialog, if it is shown.
 const int kMinThrobberDisplayTimeMs = 800;
 
 
-// Gets the favicon service for the profile in |tab_contents|.
-FaviconService* GetFaviconService(TabContents* tab_contents) {
-  return FaviconServiceFactory::GetForProfile(tab_contents->profile(),
+// Gets the favicon service for the specified profile.
+FaviconService* GetFaviconService(Profile* profile) {
+  return FaviconServiceFactory::GetForProfile(profile,
                                               Profile::EXPLICIT_ACCESS);
 }
 
-// Gets the web intents registry for the profile in |tab_contents|.
-WebIntentsRegistry* GetWebIntentsRegistry(TabContents* tab_contents) {
-  return WebIntentsRegistryFactory::GetForProfile(tab_contents->profile());
+// Gets the web intents registry for the specified profile.
+WebIntentsRegistry* GetWebIntentsRegistry(Profile* profile) {
+  return WebIntentsRegistryFactory::GetForProfile(profile);
 }
 
-// Gets the Chrome web store intents registry for the profile in |tab_contents|.
-CWSIntentsRegistry* GetCWSIntentsRegistry(TabContents* tab_contents) {
-  return CWSIntentsRegistryFactory::GetForProfile(tab_contents->profile());
+// Gets the Chrome web store intents registry for the specified profile.
+CWSIntentsRegistry* GetCWSIntentsRegistry(Profile* profile) {
+  return CWSIntentsRegistryFactory::GetForProfile(profile);
 }
 
 // Returns the action-specific string for |action|.
 string16 GetIntentActionString(const std::string& action) {
   if (!action.compare(web_intents::kActionShare))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_SHARE);
   else if (!action.compare(web_intents::kActionEdit))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_EDIT);
   else if (!action.compare(web_intents::kActionView))
     return l10n_util::GetStringUTF16(IDS_WEB_INTENTS_ACTION_VIEW);
@@ skipping 84 matching lines @@
 
 void WebIntentPickerController::UMAReporter::RecordServiceActiveDuration(
     webkit_glue::WebIntentReplyType reply_type) {
   if (!service_start_time_.is_null()) {
     web_intents::RecordServiceActiveDuration(reply_type,
         base::TimeTicks::Now() - service_start_time_);
   }
 }
 
 WebIntentPickerController::WebIntentPickerController(
-    TabContents* tab_contents)
+    content::WebContents* web_contents)
     : dialog_state_(kPickerHidden),
-      tab_contents_(tab_contents),
+      web_contents_(web_contents),
+      profile_(Profile::FromBrowserContext(web_contents->GetBrowserContext())),
       picker_(NULL),
       picker_model_(new WebIntentPickerModel()),
       uma_reporter_(new UMAReporter()),
       pending_async_count_(0),
       pending_registry_calls_count_(0),
       pending_cws_request_(false),
       picker_shown_(false),
       window_disposition_source_(NULL),
       source_intents_dispatcher_(NULL),
       intents_dispatcher_(NULL),
       service_tab_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(timer_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(dispatcher_factory_(this)) {
-  content::NavigationController* controller =
-      &tab_contents->web_contents()->GetController();
+  content::NavigationController* controller = &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));
 #if defined(TOOLKIT_VIEWS)
   cancelled_ = true;
 #endif
 }
 
 WebIntentPickerController::~WebIntentPickerController() {
@@ skipping 40 matching lines @@
   // in this method, but only after calling the registry.
   if (picker_shown_) {
     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 (tab_contents_->profile()->IsOffTheRecord()) {
+  if (profile_->IsOffTheRecord()) {
     intents_dispatcher_->SendReplyMessage(
         webkit_glue::WEB_INTENT_REPLY_FAILURE, string16());
     return;
   }
 
   picker_model_->Clear();
   picker_model_->set_action(intents_dispatcher_->GetIntent().action);
   picker_model_->set_type(intents_dispatcher_->GetIntent().type);
 
   // If the intent is explicit, skip showing the picker.
   const GURL& service = intents_dispatcher_->GetIntent().service;
   // TODO(gbillock): Decide whether to honor the default suppression flag
   // here or suppress the control for explicit intents.
   if (service.is_valid() && !suppress_defaults) {
     // 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(tab_contents_)->GetIntentServices(
+    GetWebIntentsRegistry(profile_)->GetIntentServices(
         picker_model_->action(), picker_model_->type(),
         base::Bind(
             &WebIntentPickerController::
             OnWebIntentServicesAvailableForExplicitIntent,
             weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   // As soon as the dialog is requested, block all input events
   // on the original tab.
-  tab_contents_->constrained_window_tab_helper()->BlockTabContent(true);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents_);
+  tab_contents->constrained_window_tab_helper()->BlockTabContent(true);
   SetDialogState(kPickerSetup);
 
   pending_async_count_++;
   pending_registry_calls_count_++;
-  GetWebIntentsRegistry(tab_contents_)->GetIntentServices(
+  GetWebIntentsRegistry(profile_)->GetIntentServices(
       picker_model_->action(), picker_model_->type(),
           base::Bind(&WebIntentPickerController::OnWebIntentServicesAvailable,
               weak_ptr_factory_.GetWeakPtr()));
 
-  GURL invoking_url = tab_contents_->web_contents()->GetURL();
+  GURL invoking_url = web_contents_->GetURL();
   if (invoking_url.is_valid() && !suppress_defaults) {
     pending_async_count_++;
     pending_registry_calls_count_++;
-    GetWebIntentsRegistry(tab_contents_)->GetDefaultIntentService(
+    GetWebIntentsRegistry(profile_)->GetDefaultIntentService(
         picker_model_->action(), picker_model_->type(), invoking_url,
         base::Bind(&WebIntentPickerController::OnWebIntentDefaultsAvailable,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   pending_cws_request_ = true;
   pending_async_count_++;
-  GetCWSIntentsRegistry(tab_contents_)->GetIntentServices(
+  GetCWSIntentsRegistry(profile_)->GetIntentServices(
       picker_model_->action(), picker_model_->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,
     webkit_glue::WebIntentServiceData::Disposition disposition) {
   web_intents::RecordServiceInvoke(uma_bucket_);
   uma_reporter_->ResetServiceActiveTimer();
-  ExtensionService* service = tab_contents_->profile()->GetExtensionService();
+  ExtensionService* service = profile_->GetExtensionService();
   DCHECK(service);
 
 #if defined(TOOLKIT_VIEWS)
   cancelled_ = false;
 #endif
 
   // Set the default here. Activating the intent resets the picker model.
   // TODO(gbillock): we should perhaps couple the model to the dispatcher so
   // we can re-activate the model on use-another-service.
   SetDefaultServiceForSelection(url);
 
   const extensions::Extension* extension = service->GetInstalledApp(url);
 
   // TODO(smckay): this basically smells like another disposition.
   if (extension && extension->is_platform_app()) {
-    extensions::LaunchPlatformAppWithWebIntent(tab_contents_->profile(),
-        extension, intents_dispatcher_, tab_contents_->web_contents());
+    extensions::LaunchPlatformAppWithWebIntent(profile_,
+        extension, intents_dispatcher_, web_contents_);
     ClosePicker();
     return;
   }
 
   switch (disposition) {
     case webkit_glue::WebIntentServiceData::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 webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW: {
       TabContents* contents = chrome::TabContentsFactory(
-          tab_contents_->profile(),
-          tab_util::GetSiteInstanceForNewTab(
-              tab_contents_->profile(), url),
+          profile_,
+          tab_util::GetSiteInstanceForNewTab(profile_, url),
           MSG_ROUTING_NONE, NULL);
 
       // Let the controller for the target TabContents know that it is hosting a
       // web intents service.
-      contents->web_intent_picker_controller()->SetWindowDispositionSource(
-          tab_contents_->web_contents(), intents_dispatcher_);
+      WebIntentPickerController::FromWebContents(contents->web_contents())->
+          SetWindowDispositionSource(web_contents_, intents_dispatcher_);
 
       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.
-      chrome::NavigateParams params(tab_contents_->profile(), url,
+      chrome::NavigateParams params(profile_, url,
                                     content::PAGE_TRANSITION_LINK);
       params.target_contents = contents;
       params.disposition = NEW_FOREGROUND_TAB;
       params.tabstrip_add_types = TabStripModel::ADD_INHERIT_GROUP;
       chrome::Navigate(&params);
 
       service_tab_->GetController().LoadURL(
           url, content::Referrer(),
           content::PAGE_TRANSITION_AUTO_BOOKMARK, std::string());
 
@@ skipping 44 matching lines @@
       service_hash == picker_model_->default_service_hash()) {
     return;
   }
 
   DefaultWebIntentService record;
   record.action = picker_model_->action();
   record.type = picker_model_->type();
   record.service_url = url.spec();
   record.suppression = service_hash;
   record.user_date = static_cast<int>(floor(base::Time::Now().ToDoubleT()));
-  GetWebIntentsRegistry(tab_contents_)->RegisterDefaultIntentService(record);
+  GetWebIntentsRegistry(profile_)->RegisterDefaultIntentService(record);
 }
 
 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(
-          tab_contents_->profile()));
+      WebstoreInstaller::Approval::CreateWithInstallPrompt(profile_));
 
   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
-      tab_contents_->profile(), this,
-      &tab_contents_->web_contents()->GetController(), id,
+      profile_, this,
+      &web_contents_->GetController(), id,
       approval.Pass(), WebstoreInstaller::FLAG_INLINE_INSTALL);
 
   pending_async_count_++;
   installer->Start();
 }
 
 void WebIntentPickerController::OnExtensionLinkClicked(
     const std::string& id,
     WindowOpenDisposition disposition) {
   // Navigate from source tab.
   GURL extension_url(extension_urls::GetWebstoreItemDetailURLPrefix() + id);
-  chrome::NavigateParams params(tab_contents_->profile(), extension_url,
+  chrome::NavigateParams params(profile_, extension_url,
                                 content::PAGE_TRANSITION_LINK);
   params.disposition =
       (disposition == CURRENT_TAB) ? NEW_FOREGROUND_TAB : disposition;
   chrome::Navigate(&params);
 }
 
 void WebIntentPickerController::OnSuggestionsLinkClicked(
     WindowOpenDisposition disposition) {
   // Navigate from source tab.
   GURL query_url = extension_urls::GetWebstoreIntentQueryURL(
       UTF16ToUTF8(picker_model_->action()),
       UTF16ToUTF8(picker_model_->type()));
-  chrome::NavigateParams params(tab_contents_->profile(), query_url,
+  chrome::NavigateParams params(profile_, query_url,
                                 content::PAGE_TRANSITION_LINK);
   params.disposition =
       (disposition == CURRENT_TAB) ? NEW_FOREGROUND_TAB : disposition;
   chrome::Navigate(&params);
 }
 
 void WebIntentPickerController::OnUserCancelledPickerDialog() {
   if (!intents_dispatcher_)
     return;
 
@@ skipping 30 matching lines @@
           &WebIntentPickerController::DispatchToInstalledExtension,
           base::Unretained(this),
           extension_id));
 }
 
 void WebIntentPickerController::DispatchToInstalledExtension(
     const std::string& extension_id) {
   web_intents::RecordCWSExtensionInstalled(uma_bucket_);
   picker_->OnExtensionInstallSuccess(extension_id);
   WebIntentsRegistry::IntentServiceList services;
-  GetWebIntentsRegistry(tab_contents_)->GetIntentServicesForExtensionFilter(
+  GetWebIntentsRegistry(profile_)->GetIntentServicesForExtensionFilter(
       picker_model_->action(), picker_model_->type(),
       extension_id,
       &services);
 
   // Extension must be registered with registry by now.
   DCHECK(services.size() > 0);
 
   // TODO(binji): We're going to need to disambiguate if there are multiple
   // services. For now, just choose the first.
   const webkit_glue::WebIntentServiceData& service_data = services[0];
@@ skipping 21 matching lines @@
       reply_type != webkit_glue::WEB_INTENT_SERVICE_CONTENTS_CLOSED) {
     Browser* browser = browser::FindBrowserWithWebContents(service_tab_);
     if (browser) {
       int index = browser->tab_strip_model()->GetIndexOfWebContents(
           service_tab_);
       browser->tab_strip_model()->CloseTabContentsAt(
           index, TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 
       // Activate source tab.
       Browser* source_browser =
-          browser::FindBrowserWithWebContents(tab_contents_->web_contents());
+          browser::FindBrowserWithWebContents(web_contents_);
       if (source_browser) {
         int source_index = source_browser->tab_strip_model()->
-            GetIndexOfTabContents(tab_contents_);
+            GetIndexOfWebContents(web_contents_);
         chrome::ActivateTabAt(source_browser, source_index, false);
       }
     }
     service_tab_ = NULL;
   }
 
   intents_dispatcher_ = NULL;
 }
 
 void WebIntentPickerController::AddServiceToModel(
     const webkit_glue::WebIntentServiceData& service) {
-  FaviconService* favicon_service = GetFaviconService(tab_contents_);
+  FaviconService* favicon_service = GetFaviconService(profile_);
 
   picker_model_->AddInstalledService(
       service.title,
       service.service_url,
       service.disposition);
 
   pending_async_count_++;
   FaviconService::Handle handle = favicon_service->GetFaviconImageForURL(
       FaviconService::FaviconForURLParams(
-          tab_contents_->profile(),
+          profile_,
           service.service_url,
           history::FAVICON,
           gfx::kFaviconSize,
           &favicon_consumer_),
       base::Bind(
           &WebIntentPickerController::OnFaviconDataAvailable,
           weak_ptr_factory_.GetWeakPtr()));
   favicon_consumer_.SetClientData(
       favicon_service, handle, picker_model_->GetInstalledServiceCount() - 1);
 }
@@ skipping 71 matching lines @@
     picker_model_->UpdateFaviconAt(index, image_result.image);
     return;
   }
 
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnCWSIntentServicesAvailable(
     const CWSIntentsRegistry::IntentExtensionList& extensions) {
   ExtensionServiceInterface* extension_service =
-      tab_contents_->profile()->GetExtensionService();
+      profile_->GetExtensionService();
 
   std::vector<WebIntentPickerModel::SuggestedExtension> suggestions;
   for (size_t i = 0; i < extensions.size(); ++i) {
     const CWSIntentsRegistry::IntentExtensionInfo& info = extensions[i];
 
     // Do not include suggestions for already installed extensions.
     if (extension_service->GetExtensionById(UTF16ToUTF8(info.id),
                                             true)) {
       continue;
     }
 
     suggestions.push_back(WebIntentPickerModel::SuggestedExtension(
         info.name, info.id, info.average_rating));
 
     pending_async_count_++;
     net::URLFetcher* icon_url_fetcher = net::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(
-        tab_contents_->profile()->GetRequestContext());
+    icon_url_fetcher->SetRequestContext(profile_->GetRequestContext());
     icon_url_fetcher->Start();
   }
 
   picker_model_->AddSuggestedExtensions(suggestions);
 
   AsyncOperationFinished();
   pending_cws_request_ = false;
   OnIntentDataArrived();
 }
 
@@ skipping 57 matching lines @@
 
   // Reset state associated with callbacks.
   pending_async_count_ = 0;
   pending_registry_calls_count_ = 0;
   pending_cws_request_ = false;
 
   // Reset picker.
   picker_model_.reset(new WebIntentPickerModel());
   picker_shown_ = false;
 
-  DCHECK(tab_contents_);
-  tab_contents_->constrained_window_tab_helper()->BlockTabContent(false);
+  DCHECK(web_contents_);
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents_);
+  tab_contents->constrained_window_tab_helper()->BlockTabContent(false);
 }
 
 // static
 void WebIntentPickerController::DecodeExtensionIconAndResize(
     scoped_ptr<std::string> icon_response,
     const ExtensionIconAvailableCallback& callback,
     const base::Closure& unavailable_callback) {
   SkBitmap icon_bitmap;
   if (gfx::PNGCodec::Decode(
         reinterpret_cast<const unsigned char*>(icon_response->data()),
@@ skipping 103 matching lines @@
         SetDialogState(kPickerMain);
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 void WebIntentPickerController::LocationBarPickerToolClicked() {
-  DCHECK(tab_contents_);
+  DCHECK(web_contents_);
   if (window_disposition_source_ && source_intents_dispatcher_) {
     Browser* service_browser =
-        browser::FindBrowserWithWebContents(tab_contents_->web_contents());
+        browser::FindBrowserWithWebContents(web_contents_);
     if (!service_browser) return;
 
     TabContents* client_tab =
         TabContents::FromWebContents(window_disposition_source_);
     Browser* client_browser =
         browser::FindBrowserWithWebContents(window_disposition_source_);
     if (!client_browser || !client_tab) return;
     int client_index =
         client_browser->tab_strip_model()->GetIndexOfTabContents(client_tab);
     DCHECK(client_index != TabStripModel::kNoTab);
 
     source_intents_dispatcher_->ResetDispatch();
 
-    chrome::CloseWebContents(service_browser, tab_contents_->web_contents());
+    chrome::CloseWebContents(service_browser, web_contents_);
 
     // Re-open the other tab and activate the picker.
     client_browser->window()->Activate();
     client_browser->tab_strip_model()->ActivateTabAt(client_index, true);
     // The picker has been Reset() when the new tab is created; need to fully
     // reload.
-    client_tab->web_intent_picker_controller()->ReshowDialog();
+    WebIntentPickerController::FromWebContents(window_disposition_source_)->
+        ReshowDialog();
   }
   // TODO(gbillock): figure out what we ought to do in this case. Probably
   // nothing? Refresh the location bar?
 }
 
 void WebIntentPickerController::AsyncOperationFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (--pending_async_count_ == 0) {
     if (picker_)
       picker_->OnPendingAsyncCompleted();
@@ skipping 63 matching lines @@
   dialog_state_ = state;
 
   // Create picker dialog when changing away from hidden state.
   if (dialog_state_ != kPickerHidden && dialog_state_ != kPickerSetup)
     CreatePicker();
 }
 
 void WebIntentPickerController::CreatePicker() {
   // If picker is non-NULL, it was set by a test.
   if (picker_ == NULL)
-    picker_ = WebIntentPicker::Create(tab_contents_, this, picker_model_.get());
+    picker_ = WebIntentPicker::Create(web_contents_, this, picker_model_.get());
   picker_->SetActionString(GetIntentActionString(
       UTF16ToUTF8(picker_model_->action())));
   web_intents::RecordPickerShow(
       uma_bucket_, picker_model_->GetInstalledServiceCount());
   picker_shown_ = true;
 }
 
 void WebIntentPickerController::ClosePicker() {
   SetDialogState(kPickerHidden);
   if (picker_)
     picker_->Close();
 }