Mark down in web intents picker controller when it is part of a TabContents that is hosting a web i…

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 17 matching lines @@
 #include "chrome/browser/ui/intents/web_intent_picker_model.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.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_contents_observer.h"
 #include "content/public/browser/web_intents_dispatcher.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_message.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/favicon_size.h"
@@ skipping 82 matching lines @@
 }
 
 void URLFetcherTrampoline::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(!callback_.is_null());
   callback_.Run(source);
   delete source;
   delete this;
 }
 
+class SourceWindowObserver : content::WebContentsObserver {
+ public:
+  SourceWindowObserver(content::WebContents* web_contents,
+                       base::WeakPtr<WebIntentPickerController> controller)
+      : content::WebContentsObserver(web_contents),
+        controller_(controller) {}
+  virtual ~SourceWindowObserver() {}
+
+  // Implement WebContentsObserver
+  virtual void WebContentsDestroyed(content::WebContents* web_contents) {
+    if (controller_)
+      controller_->SourceWebContentsDestroyed(web_contents);
+    delete this;
+  }
+
+ private:
+  base::WeakPtr<WebIntentPickerController> controller_;
+};
+
 }  // namespace
 
 WebIntentPickerController::WebIntentPickerController(
     TabContents* tab_contents)
     : tab_contents_(tab_contents),
       picker_(NULL),
       picker_model_(new WebIntentPickerModel()),
       pending_async_count_(0),
       pending_registry_calls_count_(0),
       picker_shown_(false),
+      window_disposition_source_(NULL),
+      source_intents_dispatcher_(NULL),
       intents_dispatcher_(NULL),
       service_tab_(NULL),
       weak_ptr_factory_(this) {
   content::NavigationController* controller =
       &tab_contents->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));
 }
@@ skipping 80 matching lines @@
     GetWebIntentsRegistry(tab_contents_)->GetDefaultIntentService(
         action, type, invoking_url,
         base::Bind(&WebIntentPickerController::OnWebIntentDefaultsAvailable,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
     GetCWSIntentsRegistry(tab_contents_)->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();
 }
 
@@ skipping 23 matching lines @@
 
     case WebIntentPickerModel::DISPOSITION_WINDOW: {
       Browser* browser = browser::FindBrowserWithWebContents(
           tab_contents_->web_contents());
       TabContents* contents = chrome::TabContentsFactory(
           tab_contents_->profile(),
           tab_util::GetSiteInstanceForNewTab(
               tab_contents_->profile(), url),
           MSG_ROUTING_NONE, NULL, NULL);
 
+      // Let the controller for the target TabContents know that it is hosting a
+      // web intents service.
+      contents->web_intent_picker_controller()->SetWindowDispositionSource(
+          tab_contents_->web_contents(), intents_dispatcher_);
+
       intents_dispatcher_->DispatchIntent(contents->web_contents());
       service_tab_ = contents->web_contents();
 
       // This call performs all the tab strip manipulation, notifications, etc.
       // Since we're passing in a target_contents, it assumes that we will
       // navigate the page ourselves, though.
       chrome::NavigateParams params(browser, url,
                                     content::PAGE_TRANSITION_AUTO_BOOKMARK);
       params.target_contents = contents;
       params.disposition = NEW_FOREGROUND_TAB;
@@ skipping 370 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::SetWindowDispositionSource(
+    content::WebContents* source,
+    content::WebIntentsDispatcher* dispatcher) {
+  window_disposition_source_ = source;
+  if (window_disposition_source_) {
+    // This object is self-deleting when the source WebContents is destroyed.
+    new SourceWindowObserver(window_disposition_source_,
+                             weak_ptr_factory_.GetWeakPtr());
+  }
+
+  source_intents_dispatcher_ = dispatcher;
+  if (dispatcher) {
+    dispatcher->RegisterReplyNotification(
+      base::Bind(&WebIntentPickerController::SourceDispatcherReplied,
+                 weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void WebIntentPickerController::SourceWebContentsDestroyed(
+    content::WebContents* source) {
+  window_disposition_source_ = NULL;
+}
+
+void WebIntentPickerController::SourceDispatcherReplied(
+    webkit_glue::WebIntentReplyType reply_type) {
+  source_intents_dispatcher_ = NULL;
+}
+
+bool WebIntentPickerController::ShowLocationBarPickerTool() {
+  return window_disposition_source_ || source_intents_dispatcher_;
+}
+
 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];
   picker_model_->AddInstalledService(
       service_data.title, service_data.service_url,
       ConvertDisposition(service_data.disposition));
@@ skipping 15 matching lines @@
   // If picker is non-NULL, it was set by a test.
   if (picker_ == NULL)
     picker_ = WebIntentPicker::Create(tab_contents_, this, picker_model_.get());
   picker_shown_ = true;
 }
 
 void WebIntentPickerController::ClosePicker() {
   if (picker_)
     picker_->Close();
 }