[WebIntents, Gtk] "Waiting for Suggestion" dialog

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 27 matching lines @@
 struct WebIntentServiceData;
 }
 
 // Controls the creation of the WebIntentPicker UI and forwards the user's
 // intent handler choice back to the WebContents object.
 class WebIntentPickerController
     : public content::NotificationObserver,
       public WebIntentPickerDelegate,
       public extensions::WebstoreInstaller::Delegate {
  public:
+
+  // The various states that the UI may be in. Public for testing.
+  enum WebIntentPickerState {
+    kPickerHidden,  // Picker not displayed at all.
+    kPickerSetup,  // Initial setup. Acquires data, keeps picker hidden.
+    kPickerWaiting, // Displaying "waiting for CWS".
+    kPickerWaitLong,  // "waiting" has displayed for longer than min. time.
+    kPickerMain,  // Displaying main picker dialog.
+  };
+
+  // Events that happen during picker life time. Drive state machine.
+  enum WebIntentPickerEvent {
+    kPickerEventHiddenSetupTimeout,  // Time for hidden setup exired.
+    kPickerEventMaxWaitTimeExceeded,  // Exceeded max wait time for CWS results.
+    kPickerEventRegistryData,  // Data from the registry has arrived.
+    kPickerEventDataComplete,  // Data from registry and CWS has arrived.

[Greg Billock, 2012/08/08 23:47:11]

Better to just have discrete events and figure out what they mean for the FSM in
the code, so have kPickerEventDataCWS.

[groby-ooo-7-16, 2012/08/09 21:59:56]

CWS data by itself does _never_ cause any transition, though. That's why it's
just a bool.

On 2012/08/08 23:47:11, Greg Billock wrote:

+  };
+
   explicit WebIntentPickerController(TabContents* tab_contents);
   virtual ~WebIntentPickerController();
 
   // 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,
@@ skipping 85 matching lines @@
                               history::FaviconData favicon_data);
 
   // Called when IntentExtensionInfo is returned from the CWSIntentsRegistry.
   void OnCWSIntentServicesAvailable(
       const CWSIntentsRegistry::IntentExtensionList& extensions);
 
   // Called when a suggested extension's icon is fetched.
   void OnExtensionIconURLFetchComplete(const string16& extension_id,
                                        const net::URLFetcher* source);
 
+  // Called whenever intent data (both from registry and CWS) arrives.
+  void OnIntentDataArrived();
+
   typedef base::Callback<void(const gfx::Image&)>
       ExtensionIconAvailableCallback;
   // Called on a worker thread to decode and resize the extension's icon.
   static void DecodeExtensionIconAndResize(
       scoped_ptr<std::string> icon_response,
       const ExtensionIconAvailableCallback& callback,
       const base::Closure& unavailable_callback);
 
   // Called when an extension's icon is successfully decoded and resized.
   void OnExtensionIconAvailable(const string16& extension_id,
                                 const gfx::Image& icon_image);
 
   // Called when an extension's icon failed to be decoded or resized.
   void OnExtensionIconUnavailable(const string16& extension_id);
 
   // When an extension is installed, all that is known is the extension id.
   // This callback receives the intent service data for that extension.
   // |services| must be a non-empty list.
   void OnExtensionInstallServiceAvailable(
       const std::vector<webkit_glue::WebIntentServiceData>& services);
 
+  // Signals that a picker event has occurred.
+  void OnPickerEvent(WebIntentPickerEvent event);

[Greg Billock, 2012/08/08 23:47:11]

Why do we need this? Shouldn't the callbacks themselves update the state?

[groby-ooo-7-16, 2012/08/09 21:59:56]

OnPickerEvent handles edges of the graph, SetDialogState does the work
associated with activating nodes.

+
   // Decrements the |pending_async_count_| and notifies the picker if it
   // reaches zero.
   void AsyncOperationFinished();
 
+  // Invoke the specified service at |service_url| with chosen |disposition|.
+  void InvokeService(const WebIntentPickerModel::InstalledService& service);
+
+  // Sets current dialog state.
+  void SetDialogState(WebIntentPickerState state);
+
   // Helper to create picker dialog UI.
   void CreatePicker();
 
   // Closes the currently active picker.
   void ClosePicker();
 
+  WebIntentPickerState dialog_state_;  // Current state of the dialog.
+
   // A weak pointer to the tab contents that the picker is displayed on.
   TabContents* tab_contents_;
 
   // A notification registrar, listening for notifications when the tab closes
   // to close the picker ui.
   content::NotificationRegistrar registrar_;
 
   // A weak pointer to the picker this controller controls.
   WebIntentPicker* picker_;
 
   // The model for the picker. Owned by this controller. It should not be NULL
   // while this controller exists, even if the picker is not shown.
   scoped_ptr<WebIntentPickerModel> picker_model_;
 
   // A count of the outstanding asynchronous calls.
   int pending_async_count_;
 
   // A count of outstanding WebIntentsRegistry calls.
   int pending_registry_calls_count_;
 
+  // Indicator that there is a pending request for cws data.
+  bool pending_cws_request_;
+
   // 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
   // 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_;
 
+  // Timer factory for minimum display time of "waiting" dialog.
+  base::WeakPtrFactory<WebIntentPickerController> timer_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(WebIntentPickerController);
 };
 
 #endif  // CHROME_BROWSER_UI_INTENTS_WEB_INTENT_PICKER_CONTROLLER_H_