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

chrome/test/automation/automation_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 <sstream>
 
 #include "chrome/test/automation/automation_proxy.h"
 
 #include "base/basictypes.h"
 #include "base/file_version_info.h"
@@ skipping 57 matching lines @@
       LOG(ERROR) << "Pre-versioning protocol detected in automation provider.";
     }
 
     server_->SignalAppLaunch(server_version);
   }
 
  private:
   AutomationProxy* server_;
 };
 
+class TabProxyNotificationMessageFilter
+    : public IPC::ChannelProxy::MessageFilter {
+ public:
+  TabProxyNotificationMessageFilter(AutomationHandleTracker* tracker)
+      : tracker_ (tracker) {
+  }
+
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    if (message.is_sync())
+      return false;
+
+    if (message.is_reply())
+      return false;
+
+    bool tab_message = IsTabNotifyMessage(message);
+    if (tab_message == false)
+      return false;
+
+    // Read tab handle from the message.
+    int tab_handle = 0;
+    void* iter = NULL;
+    if (!message.ReadInt(&iter, &tab_handle))
+      return false;
+
+    // Get AddRef-ed pointer to corresponding TabProxy object
+    TabProxy* tab = static_cast<TabProxy*>(tracker_->GetResource(tab_handle));
+    if (tab) {
+      tab->OnMessageReceived(message);
+      tab->Release();
+    }
+    return true;
+  }
+
+  static bool IsTabNotifyMessage(const IPC::Message& message) {
+    bool tab_message = true;
+    IPC_BEGIN_MESSAGE_MAP(TabProxyNotificationMessageFilter, message)
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_NavigationStateChanged, )
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_UpdateTargetUrl, )
+#if defined(OS_WIN)
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_HandleAccelerator, )
+#endif
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_TabbedOut, )
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_OpenURL, )
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_DidNavigate, )
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_NavigationFailed, )
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_TabLoaded, )
+      IPC_MESSAGE_HANDLER_GENERIC(AutomationMsg_ForwardMessageToExternalHost, )
+
+      IPC_MESSAGE_UNHANDLED(tab_message = false);
+    IPC_END_MESSAGE_MAP()
+    return tab_message;
+  }
+
+ private:
+  AutomationHandleTracker* tracker_;
+};
 }  // anonymous namespace
 
 
 AutomationProxy::AutomationProxy(int command_execution_timeout_ms)
     : app_launched_(true, false),
       initial_loads_complete_(true, false),
       new_tab_ui_load_complete_(true, false),
       shutdown_event_(new base::WaitableEvent(true, false)),
       app_launch_signaled_(0),
       perform_version_check_(false),
@@ skipping 244 matching lines @@
 
 bool AutomationProxy::WaitForURLDisplayed(GURL url, int wait_timeout) {
   const TimeTicks start = TimeTicks::Now();
   const TimeDelta timeout = TimeDelta::FromMilliseconds(wait_timeout);
   while (TimeTicks::Now() - start < timeout) {
     int window_count;
     if (!GetBrowserWindowCount(&window_count))
       return false;
 
     for (int i = 0; i < window_count; i++) {
-      BrowserProxy* window = GetBrowserWindow(i);
-      if (!window)
+      scoped_refptr<BrowserProxy> window = GetBrowserWindow(i);
+      if (!window.get())
         break;
 
       int tab_count;
       if (!window->GetTabCount(&tab_count))
         continue;
 
       for (int j = 0; j < tab_count; j++) {
-        TabProxy* tab = window->GetTab(j);
-        if (!tab)
+        scoped_refptr<TabProxy> tab = window->GetTab(j);
+        if (!tab.get())
           break;
 
         GURL tab_url;
         if (!tab->GetCurrentURL(&tab_url))
           continue;
 
         if (tab_url == url)
           return true;
       }
     }
@@ skipping 18 matching lines @@
 void AutomationProxy::OnMessageReceived(const IPC::Message& msg) {
   // This won't get called unless AutomationProxy is run from
   // inside a message loop.
   NOTREACHED();
 }
 
 void AutomationProxy::OnChannelError() {
   DLOG(ERROR) << "Channel error in AutomationProxy.";
 }
 
-WindowProxy* AutomationProxy::GetActiveWindow() {
+scoped_refptr<WindowProxy> AutomationProxy::GetActiveWindow() {
   int handle = 0;
 
   if (!SendWithTimeout(new AutomationMsg_ActiveWindow(0, &handle),
                        command_execution_timeout_ms(), NULL)) {
     return NULL;
   }
 
-  return new WindowProxy(this, tracker_.get(), handle);
+  return ProxyObjectFromHandle<WindowProxy>(handle);
 }
 
-BrowserProxy* AutomationProxy::GetBrowserWindow(int window_index) {
+scoped_refptr<BrowserProxy> AutomationProxy::GetBrowserWindow(
+    int window_index) {
   int handle = 0;
 
   if (!SendWithTimeout(new AutomationMsg_BrowserWindow(0, window_index,
                                                        &handle),
                        command_execution_timeout_ms(), NULL)) {
     DLOG(ERROR) << "GetBrowserWindow did not complete in a timely fashion";
     return NULL;
   }
 
-  if (handle == 0) {
-    return NULL;
-  }
-
-  return new BrowserProxy(this, tracker_.get(), handle);
+  return ProxyObjectFromHandle<BrowserProxy>(handle);
 }
 
-BrowserProxy* AutomationProxy::FindNormalBrowserWindow() {
+scoped_refptr<BrowserProxy> AutomationProxy::FindNormalBrowserWindow() {
   int handle = 0;
 
   if (!SendWithTimeout(new AutomationMsg_FindNormalBrowserWindow(0, &handle),
                        command_execution_timeout_ms(), NULL)) {
     return NULL;
   }
 
-  if (handle == 0) {
-    return NULL;
-  }
-
-  return new BrowserProxy(this, tracker_.get(), handle);
+  return ProxyObjectFromHandle<BrowserProxy>(handle);
 }
 
-BrowserProxy* AutomationProxy::GetLastActiveBrowserWindow() {
+scoped_refptr<BrowserProxy> AutomationProxy::GetLastActiveBrowserWindow() {
   int handle = 0;
 
   if (!SendWithTimeout(new AutomationMsg_LastActiveBrowserWindow(
       0, &handle), command_execution_timeout_ms(), NULL)) {
     DLOG(ERROR) <<
         "GetLastActiveBrowserWindow did not complete in a timely fashion";
     return NULL;
   }
 
-  return new BrowserProxy(this, tracker_.get(), handle);
+  return ProxyObjectFromHandle<BrowserProxy>(handle);
 }
 
 #if defined(OS_POSIX)
 base::file_handle_mapping_vector AutomationProxy::fds_to_map() const {
   base::file_handle_mapping_vector map;
   int src_fd = -1, dest_fd = -1;
   channel_->GetClientFileDescriptorMapping(&src_fd, &dest_fd);
   if (src_fd > -1)
     map.push_back(std::make_pair(src_fd, dest_fd));
   return map;
@@ skipping 29 matching lines @@
     tracker_->InvalidateHandle(handle);
   }
 }
 
 bool AutomationProxy::OpenNewBrowserWindow(bool show) {
   return Send(new AutomationMsg_OpenNewBrowserWindow(0, show));
 }
 
 #if defined(OS_WIN)
 // TODO(port): Replace HWNDs.
-TabProxy* AutomationProxy::CreateExternalTab(HWND parent,
-                                             const gfx::Rect& dimensions,
-                                             unsigned int style,
-                                             bool incognito,
-                                             HWND* external_tab_container) {
+scoped_refptr<TabProxy> AutomationProxy::CreateExternalTab(HWND parent,
+    const gfx::Rect& dimensions, unsigned int style, bool incognito,
+    HWND* external_tab_container) {
   IPC::Message* response = NULL;
   int handle = 0;
 
   bool succeeded =
       Send(new AutomationMsg_CreateExternalTab(0, parent, dimensions, style,
                                                incognito,
                                                external_tab_container,
                                                &handle));
   if (!succeeded) {
     return NULL;
   }
 
   DCHECK(IsWindow(*external_tab_container));
-
+  DCHECK(tracker_->GetResource(handle) == NULL);
   return new TabProxy(this, tracker_.get(), handle);
 }
 #endif  // defined(OS_WIN)
+
+template <class T> scoped_refptr<T> AutomationProxy::ProxyObjectFromHandle(
+    int handle) {
+  if (!handle)
+    return NULL;
+
+  // Get AddRef-ed pointer to the object if handle is already seen.
+  T* p = static_cast<T*>(tracker_->GetResource(handle));
+  if (!p) {
+    p = new T(this, tracker_.get(), handle);
+    p->AddRef();
+  }
+
+  // Since there is no scoped_refptr::attach.
+  scoped_refptr<T> result;
+  result.swap(&p);
+  return result;
+}