Handle automation server crashes.

chrome_frame/chrome_frame_automation.h

 // Copyright (c) 2010 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_FRAME_CHROME_FRAME_AUTOMATION_H_
 #define CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_
 
 #include <atlbase.h>
 #include <atlwin.h>
 #include <string>
@@ skipping 33 matching lines @@
   virtual void CancelAsync(void* key) = 0;
   virtual scoped_refptr<TabProxy> CreateTabProxy(int handle) = 0;
   virtual void ReleaseTabProxy(AutomationHandle handle) = 0;
   virtual std::string server_version() = 0;
 
   virtual void SendProxyConfig(const std::string&) = 0;
  protected:
   virtual ~ChromeFrameAutomationProxy() {}
 };
 
+// Forward declarations.
+class ProxyFactory;
+
 // We extend the AutomationProxy class to handle our custom
 // IPC messages
-class ChromeFrameAutomationProxyImpl : public ChromeFrameAutomationProxy,
-  // We have to derive from automationproxy since we want access to some members
-  // (tracker_ & channel_) - simple aggregation wont work;
-  // .. and non-public inheritance is verboten.
-  public AutomationProxy {
+class ChromeFrameAutomationProxyImpl
+  : public ChromeFrameAutomationProxy,
+    // We have to derive from automationproxy since we want access to some
+    // members (tracker_ & channel_) - simple aggregation wont work;
+    // .. and non-public inheritance is verboten.
+    public AutomationProxy {
  public:
+  ~ChromeFrameAutomationProxyImpl();
   virtual void SendAsAsync(
       IPC::SyncMessage* msg,
       SyncMessageReplyDispatcher::SyncMessageCallContext* context,
       void* key);
 
+  // Called on the worker thread.
+  virtual void OnChannelError();
+
   virtual void CancelAsync(void* key);
 
   virtual scoped_refptr<TabProxy> CreateTabProxy(int handle);
   virtual void ReleaseTabProxy(AutomationHandle handle);
   virtual std::string server_version() {
     return AutomationProxy::server_version();
   }
 
   virtual bool Send(IPC::Message* msg) {
     return AutomationProxy::Send(msg);
   }
 
   virtual void SendProxyConfig(const std::string& p) {
     AutomationProxy::SendProxyConfig(p);
   }
 
  protected:
-  explicit ChromeFrameAutomationProxyImpl(int launch_timeout);
-  ~ChromeFrameAutomationProxyImpl();
+  friend class AutomationProxyCacheEntry;
+  ChromeFrameAutomationProxyImpl(AutomationProxyCacheEntry* entry,
+                                 int launch_timeout);
+
   class CFMsgDispatcher;
+  class TabProxyNotificationMessageFilter;
+
   scoped_refptr<CFMsgDispatcher> sync_;
-  class TabProxyNotificationMessageFilter;
   scoped_refptr<TabProxyNotificationMessageFilter> message_filter_;
-  friend class ProxyFactory;
+  AutomationProxyCacheEntry* proxy_entry_;
 };
 
-// This structure contains information used for launching chrome.
-struct ChromeFrameLaunchParams {
-  int automation_server_launch_timeout;
-  GURL url;
-  GURL referrer;
-  FilePath profile_path;
+// This class contains information used for launching chrome.
+class ChromeFrameLaunchParams :  // NOLINT
+    public base::RefCounted<ChromeFrameLaunchParams> {
+ public:
+  ChromeFrameLaunchParams(const GURL& url, const GURL& referrer,
+                          const FilePath& profile_path,
+                          const std::wstring& profile_name,
+                          const std::wstring& extra_arguments,
+                          bool incognito, bool widget_mode)
+    : launch_timeout_(kCommandExecutionTimeout), url_(url),
+      referrer_(referrer), profile_path_(profile_path),
+      profile_name_(profile_name), extra_arguments_(extra_arguments),
+      version_check_(true), incognito_mode_(incognito),
+      is_widget_mode_(widget_mode) {
+  }
+
+  ~ChromeFrameLaunchParams() {
+  }
+
+  void set_launch_timeout(int timeout) {
+    launch_timeout_ = timeout;
+  }
+
+  int launch_timeout() const {
+    return launch_timeout_;
+  }
+
+  const GURL& url() const {
+    return url_;
+  }
+
+  void set_url(const GURL& url) {
+    url_ = url;
+  }
+
+  const GURL& referrer() const {
+    return referrer_;
+  }
+
+  void set_referrer(const GURL& referrer) {
+    referrer_ = referrer;
+  }
+
+  const FilePath& profile_path() const {
+    return profile_path_;
+  }
+
+  const std::wstring& profile_name() const {
+    return profile_name_;
+  }
+
+  const std::wstring& extra_arguments() const {
+    return extra_arguments_;
+  }
+
+  bool version_check() const {
+    return version_check_;
+  }
+
+  void set_version_check(bool check) {
+    version_check_ = check;
+  }
+
+  bool incognito() const {
+    return incognito_mode_;
+  }
+
+  bool widget_mode() const {
+    return is_widget_mode_;
+  }
+
+ protected:
+  int launch_timeout_;
+  GURL url_;
+  GURL referrer_;
+  FilePath profile_path_;
+  std::wstring profile_name_;
+  std::wstring extra_arguments_;
+  bool version_check_;
+  bool incognito_mode_;
+  bool is_widget_mode_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromeFrameLaunchParams);
+};
+
+// Callback when chrome process launch is complete and automation handshake
+// (Hello message) is established.
+struct DECLSPEC_NOVTABLE LaunchDelegate {  // NOLINT
+  virtual void LaunchComplete(ChromeFrameAutomationProxy* proxy,
+                              AutomationLaunchResult result) = 0;
+  virtual void AutomationServerDied() = 0;
+};  // NOLINT
+
+// Manages a cached ChromeFrameAutomationProxyImpl entry and holds
+// reference-less pointers to LaunchDelegate(s) to be notified in case
+// of automation server process changes.
+class AutomationProxyCacheEntry
+    : public base::RefCounted<AutomationProxyCacheEntry> {
+ public:
+  AutomationProxyCacheEntry(ChromeFrameLaunchParams* params,
+                            LaunchDelegate* delegate);
+
+  ~AutomationProxyCacheEntry();
+
+  void AddDelegate(LaunchDelegate* delegate);
+  void RemoveDelegate(LaunchDelegate* delegate, base::WaitableEvent* done,
+                      bool* was_last_delegate);
+
+  void StartSendUmaInterval(ChromeFrameHistogramSnapshots* snapshots,
+                            int send_interval);
+
+  DWORD WaitForThread(DWORD timeout) {  // NOLINT
+    DCHECK(thread_.get());
+    return ::WaitForSingleObject(thread_->thread_handle(), timeout);
+  }
+
+  bool IsSameProfile(const std::wstring& name) const {
+    return lstrcmpiW(name.c_str(), profile_name.c_str()) == 0;
+  }
+
+  base::Thread* thread() const {
+    return thread_.get();
+  }
+
+  MessageLoop* message_loop() const {
+    return thread_->message_loop();
+  }
+
+  bool IsSameThread(PlatformThreadId id) const {
+    return thread_->thread_id() == id;
+  }
+
+  ChromeFrameAutomationProxyImpl* proxy() const {
+    DCHECK(IsSameThread(PlatformThread::CurrentId()));
+    return proxy_.get();
+  }
+
+  // Called by the proxy when the automation server has unexpectedly gone away.
+  void OnChannelError();
+
+ protected:
+  void CreateProxy(ChromeFrameLaunchParams* params,
+                   LaunchDelegate* delegate);
+  void SendUMAData();
+
+ protected:
   std::wstring profile_name;
-  std::wstring extra_chrome_arguments;
-  bool perform_version_check;
-  bool incognito_mode;
-  bool is_widget_mode;
+  scoped_ptr<base::Thread> thread_;
+  scoped_ptr<ChromeFrameAutomationProxyImpl> proxy_;
+  AutomationLaunchResult launch_result_;
+  typedef std::vector<LaunchDelegate*> LaunchDelegates;
+  LaunchDelegates launch_delegates_;
+  // Used for UMA histogram logging to measure the time for the chrome
+  // automation server to start;
+  base::TimeTicks automation_server_launch_start_time_;
+  ChromeFrameHistogramSnapshots* snapshots_;
+  int uma_send_interval_;
 };
 
 // We must create and destroy automation proxy in a thread with a message loop.
 // Hence thread cannot be a member of the proxy.
 class ProxyFactory {
  public:
-  // Callback when chrome process launch is complete and automation handshake
-  // (Hello message) is established.
-  struct DECLSPEC_NOVTABLE LaunchDelegate {  // NOLINT
-    virtual void LaunchComplete(ChromeFrameAutomationProxy* proxy,
-                                AutomationLaunchResult result) = 0;
-  };  // NOLINT
-
   ProxyFactory();
   virtual ~ProxyFactory();
 
+  // Fetches or creates a new automation server instance.
+  // delegate may be NULL.  If non-null, a pointer to the delegate will
+  // be stored for the lifetime of the automation process or until
+  // ReleaseAutomationServer is called.
   virtual void GetAutomationServer(LaunchDelegate* delegate,
-                                   const ChromeFrameLaunchParams& params,
+                                   ChromeFrameLaunchParams* params,
                                    void** automation_server_id);
-  virtual bool ReleaseAutomationServer(void* server_id);
+  virtual bool ReleaseAutomationServer(void* server_id,
+                                       LaunchDelegate* delegate);
 
  private:
-  struct ProxyCacheEntry {
-    std::wstring profile_name;
-    int ref_count;
-    scoped_ptr<base::Thread> thread;
-    ChromeFrameAutomationProxyImpl* proxy;
-    AutomationLaunchResult launch_result;
-    explicit ProxyCacheEntry(const std::wstring& profile);
-  };
-
-  void CreateProxy(ProxyCacheEntry* entry,
-                   const ChromeFrameLaunchParams& params,
-                   LaunchDelegate* delegate);
-  void ReleaseProxy(ProxyCacheEntry* entry, base::WaitableEvent* done);
-
-  void SendUMAData(ProxyCacheEntry* proxy_entry);
-
-  typedef StackVector<ProxyCacheEntry*, 4> Vector;
+  typedef StackVector<scoped_refptr<AutomationProxyCacheEntry>, 4> Vector;
   Vector proxies_;
   // Lock if we are going to call GetAutomationServer from more than one thread.
   Lock lock_;
 
-  // Used for UMA histogram logging to measure the time for the chrome
-  // automation server to start;
-  base::TimeTicks automation_server_launch_start_time_;
-
   // Gathers histograms to be sent to Chrome.
   ChromeFrameHistogramSnapshots chrome_frame_histograms_;
 
   // Interval for sending UMA data
   int uma_send_interval_;
 };
 
 // Handles all automation requests initiated from the chrome frame objects.
 // These include the chrome tab/chrome frame activex/chrome frame npapi
 // plugin objects.
 class ChromeFrameAutomationClient
     : public CWindowImpl<ChromeFrameAutomationClient>,
       public TaskMarshallerThroughWindowsMessages<ChromeFrameAutomationClient>,
       public base::RefCountedThreadSafe<ChromeFrameAutomationClient>,
       public PluginUrlRequestDelegate,
       public TabProxy::TabProxyDelegate,
-      public ProxyFactory::LaunchDelegate {
+      public LaunchDelegate {
  public:
   ChromeFrameAutomationClient();
   ~ChromeFrameAutomationClient();
 
   // Called from UI thread.
   virtual bool Initialize(ChromeFrameDelegate* chrome_frame_delegate,
-                          const ChromeFrameLaunchParams& chrome_launch_params);
+                          ChromeFrameLaunchParams* chrome_launch_params);
   void Uninitialize();
+  void NotifyAndUninitialize();
 
   virtual bool InitiateNavigation(const std::string& url,
                                   const std::string& referrer,
                                   bool is_privileged);
   virtual bool NavigateToIndex(int index);
   bool ForwardMessageFromExternalHost(const std::string& message,
                                       const std::string& origin,
                                       const std::string& target);
   bool SetProxySettings(const std::string& json_encoded_proxy_settings);
 
@@ skipping 91 matching lines @@
   // Sends an IPC message to the external tab container requesting it to run
   // unload handlers on the page.
   void RunUnloadHandlers(HWND notification_window, int notification_message);
 
   // Sets the current zoom level on the tab.
   void SetZoomLevel(PageZoom::Function zoom_level);
 
  protected:
   // ChromeFrameAutomationProxy::LaunchDelegate implementation.
   virtual void LaunchComplete(ChromeFrameAutomationProxy* proxy,
-                            AutomationLaunchResult result);
+                              AutomationLaunchResult result);
+  virtual void AutomationServerDied();
+
   // TabProxyDelegate implementation
   virtual void OnMessageReceived(TabProxy* tab, const IPC::Message& msg);
   virtual void OnChannelError(TabProxy* tab);
 
   void CreateExternalTab();
   AutomationLaunchResult CreateExternalTabComplete(HWND chrome_window,
                                                    HWND tab_window,
                                                    int tab_handle);
   // Called in UI thread. Here we fire event to the client notifying for
   // the result of Initialize() method call.
   void InitializeComplete(AutomationLaunchResult result);
 
   virtual void OnFinalMessage(HWND wnd) {
     Release();
   }
 
+  scoped_refptr<ChromeFrameLaunchParams> launch_params() {
+    return chrome_launch_params_;
+  }
+
  private:
   void OnMessageReceivedUIThread(const IPC::Message& msg);
   void OnChannelErrorUIThread();
 
   HWND chrome_window() const { return chrome_window_; }
-  void BeginNavigate(const GURL& url, const GURL& referrer);
+  void BeginNavigate();
   void BeginNavigateCompleted(AutomationMsg_NavigationResponseValues result);
 
   // Helpers
   void ReportNavigationError(AutomationMsg_NavigationResponseValues error_code,
                              const std::string& url);
   bool is_initialized() const {
     return init_state_ == INITIALIZED;
   }
 
   HWND parent_window_;
@@ skipping 25 matching lines @@
   bool handle_top_level_requests_;
   ProxyFactory* proxy_factory_;
   int tab_handle_;
   // Only used if we attach to an existing tab.
   uint64 external_tab_cookie_;
 
   // Set to true if we received a navigation request prior to the automation
   // server being initialized.
   bool navigate_after_initialization_;
 
-  ChromeFrameLaunchParams chrome_launch_params_;
+  scoped_refptr<ChromeFrameLaunchParams> chrome_launch_params_;
 
   // When host network stack is used, this object is in charge of
   // handling network requests.
   PluginUrlRequestManager* url_fetcher_;
   PluginUrlRequestManager::ThreadSafeFlags url_fetcher_flags_;
 
   bool ProcessUrlRequestMessage(TabProxy* tab, const IPC::Message& msg,
                                 bool ui_thread);
 
   // PluginUrlRequestDelegate implementation. Simply adds tab's handle
@@ skipping 12 matching lines @@
  public:
   void SetUrlFetcher(PluginUrlRequestManager* url_fetcher) {
     DCHECK(url_fetcher != NULL);
     url_fetcher_ = url_fetcher;
     url_fetcher_flags_ = url_fetcher->GetThreadSafeFlags();
     url_fetcher_->set_delegate(this);
   }
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_AUTOMATION_H_