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"
@@ skipping 120 matching lines @@
 }
 
 }  // namespace
 
 WebIntentPickerController::WebIntentPickerController(
     TabContentsWrapper* wrapper)
     : wrapper_(wrapper),
       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();
   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.
 void WebIntentPickerController::SetIntentsDispatcher(
     content::WebIntentsDispatcher* intents_dispatcher) {
   intents_dispatcher_ = intents_dispatcher;
   intents_dispatcher_->RegisterReplyNotification(
       base::Bind(&WebIntentPickerController::OnSendReturnMessage,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+// TODO(gbillock): remove the browser arg; unused.
 void WebIntentPickerController::ShowDialog(Browser* browser,
                                            const string16& action,
                                            const string16& type) {
   // Only show a picker once.
   // TODO(gbillock): There's a hole potentially admitting multiple
   // in-flight dispatches since we don't create the picker
   // in this method, but only after calling the registry.
   if (picker_shown_) {
     if (intents_dispatcher_) {
       intents_dispatcher_->SendReplyMessage(
@@ skipping 36 matching lines @@
       // required to find disposition set by service.)
       pending_async_count_++;
       GetWebIntentsRegistry(wrapper_)->GetIntentServices(
           action, type, base::Bind(
               &WebIntentPickerController::WebIntentServicesForExplicitIntent,
               weak_ptr_factory_.GetWeakPtr()));
       return;
     }
   }
 
-  pending_async_count_+= 2;
+  pending_async_count_ += 2;
+  pending_registry_calls_count_ += 1;
+
   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) {
@@ skipping 171 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();
   AsyncOperationFinished();
-
-  CreatePicker();
-  picker_->SetActionString(GetIntentActionString(
-      UTF16ToUTF8(picker_model_->action())));
 }
 
 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();
     OnServiceChosen(services[i].service_url,
                     ConvertDisposition(services[i].disposition));
     AsyncOperationFinished();
     return;
   }
 
   // No acceptable extension. The intent cannot be dispatched.
   intents_dispatcher_->SendReplyMessage(
       webkit_glue::WEB_INTENT_REPLY_FAILURE,  ASCIIToUTF16(
           "Explicit extension URL is not available."));
 
   AsyncOperationFinished();
 }
 
+void WebIntentPickerController::OnWebIntentDefaultsAvailable(
+    const DefaultWebIntentService& default_service) {
+  if (!default_service.service_url.empty()) {
+    DCHECK(default_service.suppression == 0);
+    picker_model_->set_default_service_url(default_service.service_url);
+  }
+
+  RegistryCallsCompleted();
+  AsyncOperationFinished();
+}
+
+void WebIntentPickerController::RegistryCallsCompleted() {
+  pending_registry_calls_count_--;
+  if (pending_registry_calls_count_ != 0) return;
+
+  if (!picker_model_->default_service_url().empty()) {
+    // If there's a default service, dispatch to it immediately
+    // without showing the picker.
+    const WebIntentPickerModel::InstalledService* default_service =

[groby-ooo-7-16, 2012/05/01 15:28:33]

I'm wondering if we should just keep a InstalledService* on the model and set
that in OnWebIntentDefaultsAvailable - this simplifies logic here to

if(!default_svc || default_svc == INLINE) {
  CreatePicker();
  SetActionString(); // might need that for inline disposition, too
}

if(default_svc)
  OnServiceChosen()

- or at least similar.

[Greg Billock, 2012/05/01 19:17:54]

That makes sense. Let's refactor that separately?

On 2012/05/01 15:28:33, groby wrote:

+        picker_model_->GetInstalledServiceWithURL(
+            GURL(picker_model_->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(picker_model_->action())));
+
+  // TODO(gbillock): handle the case of having only one service -- set
+  // the make-default checkbox to "true" upon display.

[groby-ooo-7-16, 2012/05/01 15:28:33]

Probably belongs on the model

[Greg Billock, 2012/05/01 19:17:54]

Done.

+}
+
 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 155 matching lines @@
     picker_ = WebIntentPicker::Create(browser, wrapper_, this,
                                       picker_model_.get());
   }
   picker_shown_ = true;
 }
 
 void WebIntentPickerController::ClosePicker() {
   if (picker_)
     picker_->Close();
 }