The ChromeFrameAutomationClient class needs to be refcounted as it implements...

chrome_frame/chrome_frame_automation.cc

 // Copyright (c) 2009 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_frame/chrome_frame_automation.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
@@ skipping 418 matching lines @@
     ChromeFrameDelegate* chrome_frame_delegate,
     int automation_server_launch_timeout,
     bool perform_version_check,
     const std::wstring& profile_name,
     const std::wstring& extra_chrome_arguments,
     bool incognito) {
   DCHECK(!IsWindow());
   chrome_frame_delegate_ = chrome_frame_delegate;
   incognito_ = incognito;
   ui_thread_id_ = PlatformThread::CurrentId();
-
 #ifndef NDEBUG
   // In debug mode give more time to work with a debugger.
   if (IsDebuggerPresent()) {
     // Don't use INFINITE (which is -1) or even MAXINT since we will convert
     // from milliseconds to microseconds when stored in a base::TimeDelta,
     // thus * 1000. An hour should be enough.
     automation_server_launch_timeout = 60 * 60 * 1000;
   } else {
     DCHECK_LT(automation_server_launch_timeout, MAXINT / 2000);
     automation_server_launch_timeout *= 2;
@@ skipping 19 matching lines @@
       automation_server_launch_timeout,
       profile_name, extra_chrome_arguments, perform_version_check,
       static_cast<ProxyFactory::LaunchDelegate*>(this));
 
   return true;
 }
 
 void ChromeFrameAutomationClient::Uninitialize() {
   DLOG(INFO) << __FUNCTION__;
 
+  if (init_state_ == UNINITIALIZED) {
+    DLOG(WARNING) << __FUNCTION__ << ": Automation client not initialized";
+    return;
+  }
+
   init_state_ = UNINITIALIZING;
 
   // Called from client's FinalRelease() / destructor
   // ChromeFrameAutomationClient may wait for the initialization (launch)
   // to complete while Uninitialize is called.
   // We either have to:
   // 1) Make ReleaseAutomationServer blocking call (wait until thread exits)
   // 2) Behave like a COM object i.e. increase module lock count.
   // Otherwise the DLL may get unloaded while we have running threads.
   // Unfortunately in NPAPI case we cannot increase module lock count, hence
@@ skipping 137 matching lines @@
  public:
   InstallExtensionContext(ChromeFrameAutomationClient* client,
       const FilePath& crx_path, void* user_data) : client_(client),
       crx_path_(crx_path), user_data_(user_data) {
   }
 
   ~InstallExtensionContext() {
   }
 
   void InstallExtensionComplete(AutomationMsg_ExtensionResponseValues res) {
-    client_->PostTask(FROM_HERE, NewRunnableMethod(client_,
+    client_->PostTask(FROM_HERE, NewRunnableMethod(client_.get(),
         &ChromeFrameAutomationClient::InstallExtensionComplete, crx_path_,
         user_data_, res));
     delete this;
   }
 
  private:
-  ChromeFrameAutomationClient* client_;
+  scoped_refptr<ChromeFrameAutomationClient> client_;
   FilePath crx_path_;
   void* user_data_;
 };
 
 void ChromeFrameAutomationClient::InstallExtension(
     const FilePath& crx_path,
     void* user_data) {
   if (automation_server_ == NULL) {
     InstallExtensionComplete(crx_path,
                              user_data,
@@ skipping 411 matching lines @@
         break;
       }
     }
   }
 
   return is_valid;
 }
 
 void ChromeFrameAutomationClient::CleanupRequests() {
   DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
-  while (request_map_.size()) {
-    PluginUrlRequest* request = request_map_.begin()->second;
-    if (request) {
-      int request_id = request->id();
-      request->Stop();
-    }
-  }
-
-  DCHECK(request_map_.empty());
-  request_map_.clear();
-}
-
-void ChromeFrameAutomationClient::CleanupAsyncRequests() {
-  DCHECK_EQ(PlatformThread::CurrentId(), ui_thread_id_);
 
   std::vector<scoped_refptr<PluginUrlRequest> > request_list;
   // We copy the pending requests into a temporary vector as the Stop
   // function in the request could also try to delete the request from
   // the request map and the iterator could end up being invalid.
   RequestMap::iterator index = request_map_.begin();
   while (index != request_map_.end()) {
     PluginUrlRequest* request = (*index).second;
     DCHECK(request != NULL);
     request_list.push_back(request);
@@ skipping 13 matching lines @@
     DLOG(WARNING) << "ChromeFrameAutomationClient instance reused "
                   << "with invalid tab";
     return false;
   }
 
   if (!delegate) {
     NOTREACHED();
     return false;
   }
 
-  CleanupAsyncRequests();
+  CleanupRequests();
   chrome_frame_delegate_ = delegate;
   SetParentWindow(NULL);
   return true;
 }
 
 void ChromeFrameAutomationClient::AttachExternalTab(
     intptr_t external_tab_cookie) {
   DCHECK_EQ(static_cast<TabProxy*>(NULL), tab_.get());
   DCHECK_EQ(-1, tab_handle_);
 
   external_tab_cookie_ = external_tab_cookie;
 }
 
 void ChromeFrameAutomationClient::SetPageFontSize(
     enum AutomationPageFontSize font_size) {
   if (font_size < SMALLEST_FONT ||
       font_size > LARGEST_FONT) {
       NOTREACHED() << "Invalid font size specified : "
                    << font_size;
       return;
   }
 
   Send(new AutomationMsg_SetPageFontSize(0, tab_handle_, font_size));
 }