[Web Intents] Inline installation of extensions in web intents picker.

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 "chrome/browser/ui/browser.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 "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 "net/base/load_flags.h"
 #include "skia/ext/image_operations.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image.h"
@@ skipping 22 matching lines @@
     case webkit_glue::WebIntentServiceData::DISPOSITION_INLINE:
       return WebIntentPickerModel::DISPOSITION_INLINE;
     case webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW:
       return WebIntentPickerModel::DISPOSITION_WINDOW;
     default:
       NOTREACHED();
       return WebIntentPickerModel::DISPOSITION_WINDOW;
   }
 }
 
+// Self-deleting trampoline that forwards a WebIntentsRegistry response to a
+// callback.
+class WebIntentsRegistryTrampoline : public WebIntentsRegistry::Consumer {
+ public:
+  typedef std::vector<webkit_glue::WebIntentServiceData> IntentServices;
+  typedef base::Callback<void(const IntentServices&)> ForwardingCallback;
+
+  explicit WebIntentsRegistryTrampoline(const ForwardingCallback& callback);
+  ~WebIntentsRegistryTrampoline();
+
+  // WebIntentsRegistry::Consumer implementation.
+  virtual void OnIntentsQueryDone(
+      WebIntentsRegistry::QueryID,
+      const std::vector<webkit_glue::WebIntentServiceData>& services) OVERRIDE;
+  virtual void OnIntentsDefaultsQueryDone(
+      WebIntentsRegistry::QueryID,
+      const DefaultWebIntentService& default_service) OVERRIDE {}
+
+ private:
+  // Forwarding callback from |OnIntentsQueryDone|.
+  ForwardingCallback callback_;
+};
+
+WebIntentsRegistryTrampoline::WebIntentsRegistryTrampoline(
+    const ForwardingCallback& callback)
+    : callback_(callback) {
+}
+
+WebIntentsRegistryTrampoline::~WebIntentsRegistryTrampoline() {
+}
+
+void WebIntentsRegistryTrampoline::OnIntentsQueryDone(
+    WebIntentsRegistry::QueryID,
+    const std::vector<webkit_glue::WebIntentServiceData>& services) {
+  DCHECK(!callback_.is_null());
+  callback_.Run(services);
+  delete this;
+}
+
+// Self-deleting trampoline that forwards A URLFetcher response to a callback.
 class URLFetcherTrampoline : public content::URLFetcherDelegate {
  public:
-  typedef base::Callback<void(const content::URLFetcher* source)> Callback;
+  typedef base::Callback<void(const content::URLFetcher* source)>
+      ForwardingCallback;
 
-  explicit URLFetcherTrampoline(const Callback& callback)
-      : callback_(callback) {}
-  ~URLFetcherTrampoline() {}
+  explicit URLFetcherTrampoline(const ForwardingCallback& callback);
+  ~URLFetcherTrampoline();
 
   // content::URLFetcherDelegate implementation.
-  virtual void OnURLFetchComplete(const content::URLFetcher* source) OVERRIDE {
-    callback_.Run(source);
-    delete source;
-    delete this;
-  }
+  virtual void OnURLFetchComplete(const content::URLFetcher* source) OVERRIDE;
 
  private:
-  Callback callback_;
+  // Fowarding callback from |OnURLFetchComplete|.
+  ForwardingCallback callback_;
 };
 
+URLFetcherTrampoline::URLFetcherTrampoline(const ForwardingCallback& callback)
+    : callback_(callback) {
+}
+
+URLFetcherTrampoline::~URLFetcherTrampoline() {
+}
+
+void URLFetcherTrampoline::OnURLFetchComplete(
+    const content::URLFetcher* source) {
+  DCHECK(!callback_.is_null());
+  callback_.Run(source);
+  delete source;
+  delete this;
+}
+
 }  // namespace
 
 WebIntentPickerController::WebIntentPickerController(
     TabContentsWrapper* wrapper)
     : wrapper_(wrapper),
       picker_(NULL),
       picker_model_(new WebIntentPickerModel()),
       pending_async_count_(0),
       picker_shown_(false),
       intents_dispatcher_(NULL),
@@ skipping 19 matching lines @@
 }
 
 void WebIntentPickerController::ShowDialog(Browser* browser,
                                            const string16& action,
                                            const string16& type) {
   // Only show a picker once.
   if (picker_shown_)
     return;
 
   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());
   }
 
   picker_shown_ = true;
   pending_async_count_+= 2;
-  GetWebIntentsRegistry(wrapper_)->GetIntentServices(action, type, this);
-  GetCWSIntentsRegistry(wrapper_)->GetIntentServices(action, type,
+  GetWebIntentsRegistry(wrapper_)->GetIntentServices(
+      action, type,
+      // WebIntentsRegistryTrampoline is self-deleting.
+      new WebIntentsRegistryTrampoline(
+          base::Bind(&WebIntentPickerController::OnWebIntentServicesAvailable,
+              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 == content::NOTIFICATION_TAB_CLOSING);
@@ skipping 52 matching lines @@
       break;
   }
 }
 
 void WebIntentPickerController::OnInlineDispositionWebContentsCreated(
     content::WebContents* web_contents) {
   if (web_contents)
     intents_dispatcher_->DispatchIntent(web_contents);
 }
 
+void WebIntentPickerController::OnExtensionInstallRequested(
+    const std::string& id) {
+  webstore_installer_ = new WebstoreInstaller(
+      wrapper_->profile(), this, &wrapper_->web_contents()->GetController(), id,
+      WebstoreInstaller::FLAG_INLINE_INSTALL);
+
+  pending_async_count_++;
+  webstore_installer_->Start();
+}
+
 void WebIntentPickerController::OnCancelled() {
   if (!intents_dispatcher_)
     return;
 
   if (service_tab_) {
     intents_dispatcher_->SendReplyMessage(
         webkit_glue::WEB_INTENT_SERVICE_TAB_CLOSED, string16());
   } else {
     intents_dispatcher_->SendReplyMessage(
         webkit_glue::WEB_INTENT_PICKER_CANCELLED, string16());
   }
 
   ClosePicker();
 }
 
 void WebIntentPickerController::OnClosing() {
   picker_shown_ = false;
   picker_ = NULL;
 }
 
+void WebIntentPickerController::OnExtensionInstallSuccess(
+    const std::string& id) {
+  picker_->OnExtensionInstallSuccess(id);
+  pending_async_count_++;
+  GetWebIntentsRegistry(wrapper_)->GetIntentServicesForExtensionFilter(
+      picker_model_->action(),
+      picker_model_->mimetype(),
+      id,
+      new WebIntentsRegistryTrampoline(
+          base::Bind(
+              &WebIntentPickerController::OnExtensionInstallServiceAvailable,
+              weak_ptr_factory_.GetWeakPtr())));
+  AsyncOperationFinished();
+}
+
+void WebIntentPickerController::OnExtensionInstallFailure(
+    const std::string& id,
+    const std::string& error) {
+  picker_->OnExtensionInstallFailure(id);
+  AsyncOperationFinished();
+}
+
 void WebIntentPickerController::OnSendReturnMessage(
     webkit_glue::WebIntentReplyType reply_type) {
   ClosePicker();
 
   if (service_tab_ &&
       reply_type != webkit_glue::WEB_INTENT_SERVICE_TAB_CLOSED) {
     int index = TabStripModel::kNoTab;
     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) {
         int source_index =
             source_browser->tabstrip_model()->GetIndexOfTabContents(wrapper_);
         source_browser->ActivateTabAt(source_index, false);
       }
     }
     service_tab_ = NULL;
   }
 
   intents_dispatcher_ = NULL;
 }
 
-void WebIntentPickerController::OnIntentsQueryDone(
-    WebIntentsRegistry::QueryID,
+void WebIntentPickerController::OnWebIntentServicesAvailable(
     const std::vector<webkit_glue::WebIntentServiceData>& services) {
   FaviconService* favicon_service = GetFaviconService(wrapper_);
   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,
         &favicon_consumer_,
         base::Bind(
             &WebIntentPickerController::OnFaviconDataAvailable,
             weak_ptr_factory_.GetWeakPtr()));
     favicon_consumer_.SetClientData(favicon_service, handle, i);
   }
 
   AsyncOperationFinished();
 }
 
-void WebIntentPickerController::OnIntentsDefaultsQueryDone(
-    WebIntentsRegistry::QueryID,
-    const DefaultWebIntentService& default_service) {
-}
-
 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 112 matching lines @@
     const gfx::Image& icon_image) {
   picker_model_->SetSuggestedExtensionIconWithId(extension_id, icon_image);
   AsyncOperationFinished();
 }
 
 void WebIntentPickerController::OnExtensionIconUnavailable(
     const string16& extension_id) {
   AsyncOperationFinished();
 }
 
+void WebIntentPickerController::OnExtensionInstallServiceAvailable(
+    const std::vector<webkit_glue::WebIntentServiceData>& services) {
+  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];
+  OnServiceChosen(
+      service_data.service_url,
+      ConvertDisposition(service_data.disposition));
+  AsyncOperationFinished();
+}
+
 void WebIntentPickerController::AsyncOperationFinished() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (--pending_async_count_ == 0) {
     picker_->OnPendingAsyncCompleted();
   }
 }
 
 void WebIntentPickerController::ClosePicker() {
   if (picker_) {
     picker_->Close();
   }
 }