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.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_INTENTS_WEB_INTENT_PICKER_CONTROLLER_H_
 #define CHROME_BROWSER_UI_INTENTS_WEB_INTENT_PICKER_CONTROLLER_H_
 
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 39 matching lines @@
 
   // Sets the intent data and return pathway handler object for which
   // this picker was created. The picker takes ownership of
   // |intents_dispatcher|. |intents_dispatcher| must not be NULL.
   void SetIntentsDispatcher(content::WebIntentsDispatcher* intents_dispatcher);
 
   // Shows the web intent picker given the intent |action| and MIME-type |type|.
   void ShowDialog(const string16& action,
                   const string16& type);
 
+  // Called by the location bar to see whether the web intents picker affordance
+  // should be shown. TODO(gbillock): refactor this into a
+  // LocationBarPageToolModel.
+  bool ShowLocationBarPickerTool();
+
+  // Called to notify a controller for a page hosting a web intents service
+  // that the source WebContents has been destroyed.
+  void SourceWebContentsDestroyed(content::WebContents* source);
+
  protected:
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // WebIntentPickerDelegate implementation.
   virtual void OnServiceChosen(const GURL& url,
                                Disposition disposition) OVERRIDE;
   virtual void OnInlineDispositionWebContentsCreated(
       content::WebContents* web_contents) OVERRIDE;
   virtual void OnExtensionInstallRequested(const std::string& id) OVERRIDE;
   virtual void OnExtensionLinkClicked(const std::string& id) OVERRIDE;
   virtual void OnSuggestionsLinkClicked() OVERRIDE;
   virtual void OnPickerClosed() OVERRIDE;
   virtual void OnChooseAnotherService() OVERRIDE;
   virtual void OnClosing() OVERRIDE;
 
   // extensions::WebstoreInstaller::Delegate implementation.
   virtual void OnExtensionInstallSuccess(const std::string& id) OVERRIDE;
   virtual void OnExtensionInstallFailure(const std::string& id,
                                          const std::string& error) OVERRIDE;
 
  private:
   friend class WebIntentPickerControllerTest;
   friend class WebIntentPickerControllerBrowserTest;
   friend class WebIntentPickerControllerIncognitoBrowserTest;
-  friend class InvokingTabObserver;
 
   // Gets a notification when the return message is sent to the source tab,
   // so we can close the picker dialog or service tab.
   void OnSendReturnMessage(webkit_glue::WebIntentReplyType reply_type);
 
   // Exposed for tests only.
   void set_picker(WebIntentPicker* picker) { picker_ = picker; }
 
   // Exposed for tests only.
   void set_model_observer(WebIntentPickerModelObserver* observer) {
     picker_model_->set_observer(observer);
   }
 
+  // Notify the controller that its TabContents is hosting a web intents
+  // service. Sets the source and dispatcher for the invoking client.
+  void SetWindowDispositionSource(content::WebContents* source,
+                                  content::WebIntentsDispatcher* dispatcher);
+
+  // Called to notify a controller for a page hosting a web intents service
+  // that the source dispatcher has been replied on.
+  void SourceDispatcherReplied(webkit_glue::WebIntentReplyType reply_type);

[groby-ooo-7-16, 2012/07/26 17:44:08]

It seems odd that the controller needs to know about the state of the dispatcher
- as if we've got some dependency wires crossed. 

[Greg Billock, 2012/07/26 18:03:30]

The main reason for this is that the intent may have been caused by something
not anchored to any WebContents, and so we need to get the dispatcher and
there's no other way to get it than to have a pointer.

+
   // Called by the WebIntentsRegistry, returning |services|, which is
   // a list of WebIntentServiceData matching the query.
   void OnWebIntentServicesAvailable(
       const std::vector<webkit_glue::WebIntentServiceData>& services);
 
   // Called when a default service is returned from the WebIntentsRegistry.
   // (Still called with default_service.service_url empty if there are no
   // defaults.)
   void OnWebIntentDefaultsAvailable(
       const DefaultWebIntentService& default_service);
@@ skipping 71 matching lines @@
   int pending_async_count_;
 
   // A count of outstanding WebIntentsRegistry calls.
   int pending_registry_calls_count_;
 
   // Is true if the picker is currently visible.
   // This bool is not equivalent to picker != NULL in a unit test. In that
   // case, a picker may be non-NULL before it is shown.
   bool picker_shown_;
 
+  // Weak pointer to the source WebContents for the intent if the TabContents
+  // with which this controller is associated is hosting a web intents window

[groby-ooo-7-16, 2012/07/26 17:44:08]

To clarify - did you mean "hosting a web intent service with disposition
'window'" ? (That's how I read it, but as is this might refer to a service in
Chrome instead)

[Greg Billock, 2012/07/26 18:03:30]

Yes, that's the right reading. Any better wording?

On 2012/07/26 17:44:08, groby wrote:

+  // disposition service.
+  content::WebContents* window_disposition_source_;
+
+  // If this tab is hosting a web intents service, a weak pointer to dispatcher
+  // that invoked us. Weak pointer.
+  content::WebIntentsDispatcher* source_intents_dispatcher_;
+
   // Weak pointer to the routing object for the renderer which launched the
   // intent. Contains the intent data and a way to signal back to the
   // client page.
   content::WebIntentsDispatcher* intents_dispatcher_;
 
   // Weak pointer to the tab servicing the intent. Remembered in order to
   // close it when a reply is sent.
   content::WebContents* service_tab_;
 
   // Request consumer used when asynchronously loading favicons.
   CancelableRequestConsumerTSimple<size_t> favicon_consumer_;
 
   base::WeakPtrFactory<WebIntentPickerController> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebIntentPickerController);
 };
 
 #endif  // CHROME_BROWSER_UI_INTENTS_WEB_INTENT_PICKER_CONTROLLER_H_