Add a method to the controller to close the picker/service tab when a return value is passed.

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/public/browser/notification_source.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "webkit/glue/web_intent_service_data.h"
@@ skipping 81 matching lines @@
         : 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) {
+          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() {
 }
 
@@ skipping 41 matching lines @@
                       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.
@@ skipping 18 matching lines @@
     // 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_);
 }
 
 void WebIntentPickerController::OnCancelled() {
   InvokingTabObserver forwarder(wrapper_, NULL, routing_id_);
-  forwarder.Send(new IntentsMsg_WebIntentReply(
-      0, webkit_glue::WEB_INTENT_PICKER_CANCELLED, string16(), intent_id_));
+  if (service_tab_) {
+    forwarder.Send(new IntentsMsg_WebIntentReply(
+        0, webkit_glue::WEB_INTENT_SERVICE_TAB_CLOSED, string16(), intent_id_));
+  } else {
+    forwarder.Send(new IntentsMsg_WebIntentReply(
+        0, webkit_glue::WEB_INTENT_PICKER_CANCELLED, string16(), intent_id_));

[James Hawkins, 2011/11/10 00:57:28]

Does this case mean the client tab was closed?

[Greg Billock, 2011/11/10 20:00:43]

If we get a PICKER_CANCELLED, it means the picker was closed without selecting a
service. If an inline service was selected, there's still a cancel operation on
that dialog, but now it really means SERVICE_TAB_CLOSED.

+  }
+
+  ClosePicker();
 }
 
 void WebIntentPickerController::OnClosing() {

[James Hawkins, 2011/11/10 00:57:28]

Do we still need this method?

[Greg Billock, 2011/11/10 20:00:43]

I think we technically don't need it or the calls to ClosePicker(). I'm a bit
unsure as to how we're going to make the tab modal dialog, though, so I left
them in place pretty much against that process. We can always add them back,
though. Shall I get rid of this?

+}
+
+void WebIntentPickerController::OnSendReturnMessage() {
   ClosePicker();
+
+  if (service_tab_) {
+    int index = TabStripModel::kNoTab;
+    Browser* browser = Browser::GetBrowserForController(
+        &service_tab_->controller(), &index);
+    if (browser) {
+      browser->tabstrip_model()->CloseTabContentsAt(
+          index, TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
+    }
+    service_tab_ = NULL;
+  }
 }
 
 void WebIntentPickerController::OnWebIntentDataAvailable(
     const std::vector<webkit_glue::WebIntentServiceData>& services) {
   urls_.clear();
   for (size_t i = 0; i < services.size(); ++i) {
     urls_.push_back(services[i].service_url);
   }
   service_data_ = services;
 
@@ skipping 90 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);
 }