Add a public content/ interface for intents. Use it.

chrome/browser/ui/intents/web_intent_picker_controller.cc

 // Copyright (c) 2011 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/favicon/favicon_service.h"
 #include "chrome/browser/intents/web_intents_registry.h"
 #include "chrome/browser/intents/web_intents_registry_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tabs/tab_strip_model.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_factory.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "content/browser/intents/intent_injector.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/intents_messages.h"
+#include "content/public/browser/intents_host.h"
 #include "content/public/browser/notification_source.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "webkit/glue/web_intent_service_data.h"
 
 namespace {
 
 // Gets the favicon service for the profile in |tab_contents|.
 FaviconService* GetFaviconService(TabContentsWrapper* wrapper) {
   return wrapper->profile()->GetFaviconService(Profile::EXPLICIT_ACCESS);
 }
@@ skipping 73 matching lines @@
     WebIntentPickerFactory* factory)
         : wrapper_(wrapper),
           picker_factory_(factory),
           web_intent_data_fetcher_(
               new WebIntentDataFetcher(this,
                                        GetWebIntentsRegistry(wrapper))),
           favicon_fetcher_(
               new FaviconFetcher(this, GetFaviconService(wrapper))),
           picker_(NULL),
           pending_async_count_(0),
-          routing_id_(0),
-          intent_id_(0),
           service_tab_(NULL) {
   NavigationController* controller = &wrapper->controller();
   registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                  content::Source<NavigationController>(controller));
   registrar_.Add(this, content::NOTIFICATION_TAB_CLOSING,
                  content::Source<NavigationController>(controller));
 }
 
 WebIntentPickerController::~WebIntentPickerController() {
 }
 
-void WebIntentPickerController::SetIntent(
-    int routing_id,
-    const webkit_glue::WebIntentData& intent,
-    int intent_id) {
-  routing_id_ = routing_id;
-  intent_ = intent;
-  intent_id_ = intent_id;
+void WebIntentPickerController::SetIntentsHost(
+    content::IntentsHost* intents_host) {
+  intents_host_.reset(intents_host);
+  intents_host_->RegisterReplyNotification(
+      base::Bind(&WebIntentPickerController::OnSendReturnMessage,
+                 base::Unretained(this)));
 }
 
 void WebIntentPickerController::ShowDialog(Browser* browser,
                                            const string16& action,
                                            const string16& type) {
   if (picker_ != NULL)
     return;
 
   picker_ = picker_factory_->Create(browser, wrapper_, this);
 
   // TODO(binji) Remove this check when there are implementations of the picker
   // for windows and mac.
   if (picker_ == NULL)
     return;
 
   web_intent_data_fetcher_->Fetch(action, type);
 }
 
 void WebIntentPickerController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == content::NOTIFICATION_LOAD_START ||
          type == content::NOTIFICATION_TAB_CLOSING);
   ClosePicker();
 }
 
-// Used to forward messages to the source tab from the service context.
-// Also watches the source tab contents, and if it closes, doesn't forward
-// messages.
-class InvokingTabObserver : public TabContentsObserver {
- public:
-  InvokingTabObserver(TabContentsWrapper* wrapper,
-                      IntentInjector* injector,
-                      int routing_id)
-      : TabContentsObserver(wrapper->tab_contents()),
-        wrapper_(wrapper),
-        intent_injector_(injector),
-        routing_id_(routing_id) {}
-  virtual ~InvokingTabObserver() {}
-
-  virtual void TabContentsDestroyed(TabContents* tab) OVERRIDE {
-    if (intent_injector_)
-      intent_injector_->SourceTabContentsDestroyed(tab);
-    wrapper_ = NULL;
-  }
-
-  virtual bool Send(IPC::Message* message) OVERRIDE {
-    // The injector can return exactly one message. After that we don't talk
-    // to it again, since it may have deleted itself.
-    intent_injector_ = NULL;
-
-    if (!wrapper_)
-      return false;
-
-    MessageLoopForUI::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&WebIntentPickerController::OnSendReturnMessage,
-                   base::Unretained(wrapper_->web_intent_picker_controller())));
-
-    message->set_routing_id(routing_id_);
-    return wrapper_->Send(message);
-  }
-
- private:
-  // Weak pointer to the source tab invoking the intent.
-  TabContentsWrapper* wrapper_;
-
-  // Weak pointer to the intent injector managing delivering the intent data to
-  // the service tab.
-  IntentInjector* intent_injector_;
-
-  // Renderer-side object invoking the intent.
-  int routing_id_;
-};
-
 void WebIntentPickerController::OnServiceChosen(size_t index) {
   DCHECK(index < urls_.size());
 
   bool inline_disposition = service_data_[index].disposition ==
       webkit_glue::WebIntentServiceData::DISPOSITION_INLINE;
   TabContents* new_tab_contents = NULL;
   if (inline_disposition)
     new_tab_contents = picker_->SetInlineDisposition(urls_[index]);
 
   if (new_tab_contents == NULL) {
     // 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. Also: the above conditional construction is just because
     // there isn't Mac/Win support yet. When that's there, it'll be an else.
     browser::NavigateParams params(NULL, urls_[index],
                                    content::PAGE_TRANSITION_AUTO_BOOKMARK);
     params.disposition = NEW_FOREGROUND_TAB;
     params.profile = wrapper_->profile();
     browser::Navigate(&params);
     new_tab_contents = params.target_contents->tab_contents();
     service_tab_ = new_tab_contents;
 
     ClosePicker();
   }
 
-  IntentInjector* injector = new IntentInjector(new_tab_contents);
-  injector->SetIntent(new InvokingTabObserver(wrapper_, injector, routing_id_),
-                      intent_,
-                      intent_id_);
+  intents_host_->DispatchIntent(new_tab_contents);
 }
 
 void WebIntentPickerController::OnCancelled() {
-  InvokingTabObserver forwarder(wrapper_, NULL, routing_id_);
+  if (!intents_host_.get())
+    return;
+
   if (service_tab_) {
-    forwarder.Send(new IntentsMsg_WebIntentReply(
-        0, webkit_glue::WEB_INTENT_SERVICE_TAB_CLOSED, string16(), intent_id_));
+    intents_host_->SendReplyMessage(webkit_glue::WEB_INTENT_SERVICE_TAB_CLOSED,
+                                    string16());
   } else {
-    forwarder.Send(new IntentsMsg_WebIntentReply(
-        0, webkit_glue::WEB_INTENT_PICKER_CANCELLED, string16(), intent_id_));
+    intents_host_->SendReplyMessage(webkit_glue::WEB_INTENT_PICKER_CANCELLED,
+                                    string16());
   }
 
   ClosePicker();
 }
 
 void WebIntentPickerController::OnClosing() {
 }
 
 void WebIntentPickerController::OnSendReturnMessage() {
   ClosePicker();
@@ skipping 111 matching lines @@
     if (gfx::PNGCodec::Decode(favicon_data.image_data->front(),
                               favicon_data.image_data->size(),
                               &icon_bitmap)) {
       controller_->OnFaviconDataAvailable(index, icon_bitmap);
       return;
     }
   }
 
   controller_->OnFaviconDataUnavailable(index);
 }