Make automation proxy objects to ref_counted. That allows to process async no...

chrome/test/automation/browser_proxy.cc

 // Copyright (c) 2006-2008 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/test/automation/browser_proxy.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/platform_thread.h"
@@ skipping 94 matching lines @@
 
   if (active_tab_index_response >= 0) {
     *active_tab_index = active_tab_index_response;
   } else {
     succeeded = false;
   }
 
   return succeeded;
 }
 
-TabProxy* BrowserProxy::GetTab(int tab_index) const {
+scoped_refptr<TabProxy> BrowserProxy::GetTab(int tab_index) const {
   if (!is_valid())
     return NULL;
 
-  int handle = 0;
+  int tab_handle = 0;
 
-  sender_->Send(new AutomationMsg_Tab(0, handle_, tab_index, &handle));
-  if (!handle)
+  sender_->Send(new AutomationMsg_Tab(0, handle_, tab_index, &tab_handle));
+  if (!tab_handle)
     return NULL;
 
-  return new TabProxy(sender_, tracker_, handle);
+  TabProxy* tab = static_cast<TabProxy*>(tracker_->GetResource(tab_handle));
+  if (!tab) {
+    tab = new TabProxy(sender_, tracker_, tab_handle);
+    tab->AddRef();
+  }
+
+  // Since there is no scoped_refptr::attach.
+  scoped_refptr<TabProxy> result;
+  result.swap(&tab);
+  return result;
 }
 
-TabProxy* BrowserProxy::GetActiveTab() const {
+scoped_refptr<TabProxy> BrowserProxy::GetActiveTab() const {
   return GetActiveTabWithTimeout(base::kNoTimeout, NULL);
 }
 
-TabProxy* BrowserProxy::GetActiveTabWithTimeout(uint32 timeout_ms,
-                                                bool* is_timeout) const {
+scoped_refptr<TabProxy> BrowserProxy::GetActiveTabWithTimeout(uint32 timeout_ms,
+    bool* is_timeout) const {
   int active_tab_index;
   if (!GetActiveTabIndexWithTimeout(&active_tab_index, timeout_ms, is_timeout))
     return NULL;
   return GetTab(active_tab_index);
 }
 
 bool BrowserProxy::GetTabCount(int* num_tabs) const {
   return GetTabCountWithTimeout(num_tabs, base::kNoTimeout, NULL);
 }
 
@@ skipping 214 matching lines @@
   if (!is_valid())
     return false;
 
   bool result = false;
 
   sender_->Send(new AutomationMsg_SetBooleanPreference(0, handle_, name,
                                                        value, &result));
   return result;
 }
 
-WindowProxy* BrowserProxy::GetWindow() const {
+scoped_refptr<WindowProxy> BrowserProxy::GetWindow() const {
   if (!is_valid())
-    return false;
+    return NULL;
 
   bool handle_ok = false;
   int window_handle = 0;
 
   sender_->Send(new AutomationMsg_WindowForBrowser(0, handle_, &handle_ok,
                                                    &window_handle));
   if (!handle_ok)
     return NULL;
 
-  return new WindowProxy(sender_, tracker_, window_handle);
+  WindowProxy* window =
+      static_cast<WindowProxy*>(tracker_->GetResource(window_handle));
+  if (!window) {
+    window = new WindowProxy(sender_, tracker_, window_handle);
+    window->AddRef();
+  }
+
+  // Since there is no scoped_refptr::attach.
+  scoped_refptr<WindowProxy> result;
+  result.swap(&window);
+  return result;
 }
 
-AutocompleteEditProxy* BrowserProxy::GetAutocompleteEdit() {
+scoped_refptr<AutocompleteEditProxy> BrowserProxy::GetAutocompleteEdit() {
   if (!is_valid())
     return NULL;
 
   bool handle_ok = false;
   int autocomplete_edit_handle = 0;
 
   sender_->Send(new AutomationMsg_AutocompleteEditForBrowser(
       0, handle_, &handle_ok, &autocomplete_edit_handle));
 
   if (!handle_ok)
     return NULL;
 
-  return new AutocompleteEditProxy(sender_, tracker_, autocomplete_edit_handle);
+  AutocompleteEditProxy* p = static_cast<AutocompleteEditProxy*>(
+        tracker_->GetResource(autocomplete_edit_handle));
+  
+  if (!p) {
+    p = new AutocompleteEditProxy(sender_, tracker_, autocomplete_edit_handle);
+    p->AddRef();
+  }
+
+  // Since there is no scoped_refptr::attach.
+  scoped_refptr<AutocompleteEditProxy> result;
+  result.swap(&p);
+  return result;
 }