Handling default service in the web intents picker controller.

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/default_web_intent_service.h"
 #include "chrome/browser/intents/web_intents_registry_factory.h"
 #include "chrome/browser/intents/cws_intents_registry_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.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/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"
 #include "content/public/common/url_fetcher_delegate.h"
 #include "grit/generated_resources.h"
 #include "net/base/load_flags.h"
 #include "skia/ext/image_operations.h"
@@ skipping 118 matching lines @@
   intents_dispatcher_ = intents_dispatcher;
   intents_dispatcher_->RegisterReplyNotification(
       base::Bind(&WebIntentPickerController::OnSendReturnMessage,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void WebIntentPickerController::ShowDialog(Browser* browser,
                                            const string16& action,
                                            const string16& type) {
   // Only show a picker once.
-  if (picker_shown_)
-    return;
-
+  // ??? Is this good enough? There's a hole if we don't create the picker
+  // in this method, but only after disk retrieval.
   // TODO(binji): Figure out what to do when intents are invoked from incognito
   // mode.
-  if (wrapper_->profile()->IsOffTheRecord())
+  if (picker_shown_ || wrapper_->profile()->IsOffTheRecord()) {
+    if (intents_dispatcher_) {
+      intents_dispatcher_->SendReplyMessage(
+          webkit_glue::WEB_INTENT_REPLY_FAILURE, ASCIIToUTF16(""));
+    }
     return;
+  }
 
+  browser_ = browser;
+  action_ = action;
   picker_model_->Clear();
   picker_model_->set_action(action);
   picker_model_->set_mimetype(type);
 
-  // If picker is non-NULL, it was set by a test.
-  if (picker_ == NULL) {
-    picker_ = WebIntentPicker::Create(browser, wrapper_, this,
-                                      picker_model_.get());
+  // If the intent is explicit, skip showing the picker.
+  if (intents_dispatcher_) {
+    const GURL& service = intents_dispatcher_->GetIntent().service;
+    // TODO(gbillock): When we can parse pages for the intent tag,
+    // take out this requirement that explicit intents dispatch to
+    // extension urls.
+    if (!service.is_valid() || !service.SchemeIs(chrome::kExtensionScheme)) {
+      intents_dispatcher_->SendReplyMessage(
+          webkit_glue::WEB_INTENT_REPLY_FAILURE, ASCIIToUTF16(
+              "Only extension urls are supported for explicit invocation"));
+      return;
+    }
+
+    // We get services from the registry because that must retrieve the
+    // registered extension page for this action/type if it is permitted to be
+    // dispatched.
+    pending_async_count_++;
+    GetWebIntentsRegistry(wrapper_)->GetIntentServices(
+        action, type, base::Bind(
+            &WebIntentPickerController::WebIntentServicesForExplicitIntent,
+            weak_ptr_factory_.GetWeakPtr()));
+    return;
   }
 
-  picker_->SetActionString(GetIntentActionString(UTF16ToUTF8(action)));
+  pending_async_count_ += 2;

[groby-ooo-7-16, 2012/04/24 21:36:51]

Why exactly do we keep a pending count? (Nobody implements
OnPendingAsyncCompleted except for a stub, so we can probably kill this
machinery)

[Greg Billock, 2012/04/25 16:04:32]

I thought it was used to guide the operation of the picker dialog. If not, yes,
we can scrap it. Let's do that separately though.

+  pending_registry_calls_count_ += 1;

[groby-ooo-7-16, 2012/04/24 21:36:51]

Why add 1 here? We already do that when we call the registry? (Also, why at all?
We will always call the Callback as soon as we complete, and the count will
always be 1)

[Greg Billock, 2012/04/25 16:04:32]

There's now two registry callbacks we need to wait for.
The right solution is a barrier closure, but we don't have one. :-/

On 2012/04/24 21:36:51, groby wrote:

 
-  picker_shown_ = true;
-  pending_async_count_+= 2;
   GetWebIntentsRegistry(wrapper_)->GetIntentServices(
       action, type,
           base::Bind(&WebIntentPickerController::OnWebIntentServicesAvailable,
               weak_ptr_factory_.GetWeakPtr()));
+
+  GURL invoking_url = wrapper_->web_contents()->GetURL();
+  if (invoking_url.is_valid()) {
+    pending_async_count_++;
+    pending_registry_calls_count_++;
+    GetWebIntentsRegistry(wrapper_)->GetDefaultIntentService(
+        action, type, invoking_url,
+        base::Bind(&WebIntentPickerController::OnWebIntentDefaultsAvailable,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
   GetCWSIntentsRegistry(wrapper_)->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: {
-      // TODO(gbillock): This really only handles the 'window' disposition in a
-      // quite prototype way. We need to flesh out what happens to the picker
-      // during the lifetime of the service url context, and that may mean we
-      // need to pass more information into the injector to find the picker
-      // again and close it.
       int index = TabStripModel::kNoTab;
+      // TODO(gbillock): use browser_?

[groby-ooo-7-16, 2012/04/24 21:36:51]

I believe there has been a CL (or there is one in flight) that does do that
already - the switch to WebContents?

[Greg Billock, 2012/04/25 16:04:32]

got rid of this. I'll add a todo to scrap the ShowDialog arg, as we don't need
it any more.

On 2012/04/24 21:36:51, groby wrote:

       Browser* browser = Browser::GetBrowserForController(
           &wrapper_->web_contents()->GetController(), &index);
       TabContentsWrapper* contents = Browser::TabContentsFactory(
           browser->profile(),
           tab_util::GetSiteInstanceForNewTab(
               NULL, browser->profile(), url),
           MSG_ROUTING_NONE, NULL, NULL);
 
       intents_dispatcher_->DispatchIntent(contents->web_contents());
       service_tab_ = contents->web_contents();
@@ skipping 35 matching lines @@
       wrapper_->profile(), this, &wrapper_->web_contents()->GetController(), id,
       scoped_ptr<WebstoreInstaller::Approval>(NULL),
       WebstoreInstaller::FLAG_INLINE_INSTALL);
 
   pending_async_count_++;
   installer->Start();
 }
 
 void WebIntentPickerController::OnExtensionLinkClicked(const std::string& id) {
   // Navigate from source tab.
+  // TODO(gbillock): use browser_?

[groby-ooo-7-16, 2012/04/24 21:36:51]

See above

[Greg Billock, 2012/04/25 16:04:32]

Done.

   Browser* browser =
       BrowserList::FindBrowserWithWebContents(wrapper_->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() {
@@ skipping 48 matching lines @@
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnSendReturnMessage(
     webkit_glue::WebIntentReplyType reply_type) {
   ClosePicker();
 
   if (service_tab_ &&
       reply_type != webkit_glue::WEB_INTENT_SERVICE_CONTENTS_CLOSED) {
     int index = TabStripModel::kNoTab;
+    // TODO(gbillock): use browser_?

[groby-ooo-7-16, 2012/04/24 21:36:51]

See above

[Greg Billock, 2012/04/25 16:04:32]

Done.

     Browser* browser = Browser::GetBrowserForController(
         &service_tab_->GetController(), &index);
     if (browser) {
       browser->tabstrip_model()->CloseTabContentsAt(
           index, TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
 
       // Activate source tab.
       Browser* source_browser =
           BrowserList::FindBrowserWithWebContents(wrapper_->web_contents());
       if (source_browser) {
@@ skipping 21 matching lines @@
     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, i);
   }
 
+  RegistryCallsCompleted();

[groby-ooo-7-16, 2012/04/24 21:36:51]

Why do we flag registry calls completed here, not when we get the default
service?

[Greg Billock, 2012/04/25 16:04:32]

Bad name. This is the method we want to happen when both are complete.

On 2012/04/24 21:36:51, groby wrote:

   AsyncOperationFinished();
 }
 
+void WebIntentPickerController::WebIntentServicesForExplicitIntent(
+    const std::vector<webkit_glue::WebIntentServiceData>& services) {
+  DCHECK(intents_dispatcher_);
+  DCHECK(intents_dispatcher_->GetIntent().service.is_valid());
+  for (size_t i = 0; i < services.size(); ++i) {
+    if (services[i].service_url != intents_dispatcher_->GetIntent().service)
+      continue;
+
+    if (services[i].disposition ==
+        webkit_glue::WebIntentServiceData::DISPOSITION_INLINE)
+      CreatePicker();

[groby-ooo-7-16, 2012/04/24 21:36:51]

This is more of a TBD, but I really think we need to (at some point) separate
the idea of the picker and the inline disposition contents into two separate
objects.

[Greg Billock, 2012/04/25 16:04:32]

Makes sense.

+    OnServiceChosen(services[i].service_url,
+                    ConvertDisposition(services[i].disposition));
+    return;
+  }
+
+  // We did not find an acceptable extension. The intent cannot
+  // be dispatched.
+  intents_dispatcher_->SendReplyMessage(
+      webkit_glue::WEB_INTENT_REPLY_FAILURE,  ASCIIToUTF16(
+          "Explicit extension URL is not available."));
+
+  // Finished.
+  AsyncOperationFinished();
+}
+
+void WebIntentPickerController::OnWebIntentDefaultsAvailable(
+    const DefaultWebIntentService& default_service) {
+  if (!default_service.service_url.empty()) {
+    DCHECK(default_service.suppression == 0);
+    default_service_url_ = default_service.service_url;
+  }
+
+  RegistryCallsCompleted();
+  AsyncOperationFinished();
+}
+
+void WebIntentPickerController::RegistryCallsCompleted() {
+  if (--pending_registry_calls_count_ != 0) return;
+
+  if (!default_service_url_.empty()) {
+    // If there's a default service, dispatch to it immediately
+    // without showing the picker.
+    const WebIntentPickerModel::InstalledService* default_service =
+        picker_model_->GetInstalledServiceWithURL(GURL(default_service_url_));
+
+    if (default_service != NULL) {
+      if (default_service->disposition ==
+          WebIntentPickerModel::DISPOSITION_INLINE)
+        CreatePicker();
+      OnServiceChosen(default_service->url, default_service->disposition);
+      return;
+    }
+  }
+
+  CreatePicker();
+  picker_->SetActionString(GetIntentActionString(UTF16ToUTF8(action_)));
+
+  // TODO(gbillock): handle the case of having only one service -- set
+  // the make-default checkbox to "true" upon display.
+}
+
 void WebIntentPickerController::OnFaviconDataAvailable(
     FaviconService::Handle handle, history::FaviconData favicon_data) {
   size_t index = favicon_consumer_.GetClientDataForCurrentRequest();
   if (favicon_data.is_valid()) {
     SkBitmap icon_bitmap;
 
     if (gfx::PNGCodec::Decode(favicon_data.image_data->front(),
                               favicon_data.image_data->size(),
                               &icon_bitmap)) {
       gfx::Image icon_image(new SkBitmap(icon_bitmap));
@@ skipping 140 matching lines @@
 }
 
 void WebIntentPickerController::AsyncOperationFinished() {
   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.
+  // Use browser_?
+  Browser* browser =
+      BrowserList::FindBrowserWithWebContents(wrapper_->web_contents());
+  if (picker_ == NULL) {
+    picker_ = WebIntentPicker::Create(browser, wrapper_, this,
+                                      picker_model_.get());
+  }
+  picker_shown_ = true;
+}
+
 void WebIntentPickerController::ClosePicker() {
   if (picker_)
     picker_->Close();
 }