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

chrome/test/ui/ui_test.cc

 // Copyright (c) 2006-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/test/ui/ui_test.h"
 
 #include <set>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 373 matching lines @@
   }
 #else
   // TODO(port): above code is very Windows-specific; we need to
   // figure out and abstract out how we'll handle finding any existing
   // running process, etc. on other platforms.
   NOTIMPLEMENTED();
 #endif
 }
 
 void UITest::QuitBrowser() {
-  typedef std::vector<BrowserProxy*> BrowserVector;
+  typedef std::vector<scoped_refptr<BrowserProxy> > BrowserVector;
 
   // There's nothing to do here if the browser is not running.
   if (IsBrowserRunning()) {
     automation()->SetFilteredInet(false);
     BrowserVector browsers;
 
     // Build up a list of HWNDs; we do this as a separate step so that closing
     // the windows doesn't mess up the iteration.
     int window_count = 0;
     EXPECT_TRUE(automation()->GetBrowserWindowCount(&window_count));
 
     for (int i = 0; i < window_count; ++i) {
-      BrowserProxy* browser_proxy = automation()->GetBrowserWindow(i);
+      scoped_refptr<BrowserProxy> browser_proxy =
+          automation()->GetBrowserWindow(i);
       browsers.push_back(browser_proxy);
     }
 
 // This is disabled for now on linux because it causes a crash. See
 // http://crbug.com/12334
 #if !defined(OS_LINUX)
     for (BrowserVector::iterator iter = browsers.begin();
       iter != browsers.end(); ++iter) {
       // Use ApplyAccelerator since it doesn't wait
       (*iter)->ApplyAccelerator(IDC_CLOSE_WINDOW);
-      delete (*iter);
     }
 #endif
 
+    browsers.clear();
+
     // Now, drop the automation IPC channel so that the automation provider in
     // the browser notices and drops its reference to the browser process.
     server_->Disconnect();
 
     // Wait for the browser process to quit. It should quit once all tabs have
     // been closed.
     int timeout = 5000;
 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
     timeout = 500000;
 #endif
@@ skipping 16 matching lines @@
 void UITest::CleanupAppProcesses() {
   TerminateAllChromeProcesses(user_data_dir());
 
   // Suppress spammy failures that seem to be occurring when running
   // the UI tests in single-process mode.
   // TODO(jhughes): figure out why this is necessary at all, and fix it
   if (!in_process_renderer_)
     AssertAppNotRunning(L"Unable to quit all browser processes.");
 }
 
-TabProxy* UITest::GetActiveTab(int window_index) {
+scoped_refptr<TabProxy> UITest::GetActiveTab(int window_index) {
   EXPECT_GE(window_index, 0);
   int window_count;
   // Use EXPECT rather than ASSERT here because ASSERT_* returns void.
   EXPECT_TRUE(automation()->GetBrowserWindowCount(&window_count));
   EXPECT_GT(window_count, window_index);
-  scoped_ptr<BrowserProxy> window_proxy(automation()->
+  scoped_refptr<BrowserProxy> window_proxy(automation()->
       GetBrowserWindow(window_index));
   if (!window_proxy.get())
     return NULL;
 
   int active_tab_index = -1;
   EXPECT_TRUE(window_proxy->GetActiveTabIndex(&active_tab_index));
   if (active_tab_index == -1)
     return NULL;
 
   return window_proxy->GetTab(active_tab_index);
 }
 
+scoped_refptr<TabProxy> UITest::GetActiveTab() {
+  return GetActiveTab(0);
+}
+
 void UITest::NavigateToURLAsync(const GURL& url) {
-  scoped_ptr<TabProxy> tab_proxy(GetActiveTab());
+  scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
   ASSERT_TRUE(tab_proxy.get());
   if (!tab_proxy.get())
     return;
 
   tab_proxy->NavigateToURLAsync(url);
 }
 
 void UITest::NavigateToURL(const GURL& url) {
-  scoped_ptr<TabProxy> tab_proxy(GetActiveTab());
+  scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
   ASSERT_TRUE(tab_proxy.get());
   if (!tab_proxy.get())
     return;
 
   bool is_timeout = true;
   ASSERT_TRUE(tab_proxy->NavigateToURLWithTimeout(
       url, command_execution_timeout_ms(), &is_timeout)) << url.spec();
   ASSERT_FALSE(is_timeout) << url.spec();
 }
 
@@ skipping 44 matching lines @@
       return true;  // Bookmark bar visibility change complete.
 
     // Give it a chance to catch up.
     PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
   }
   return false;
 }
 #endif  // defined(OS_WIN)
 
 GURL UITest::GetActiveTabURL(int window_index) {
-  scoped_ptr<TabProxy> tab_proxy(GetActiveTab(window_index));
+  scoped_refptr<TabProxy> tab_proxy(GetActiveTab(window_index));
   if (!tab_proxy.get())
     return GURL();
 
   GURL url;
   if (!tab_proxy->GetCurrentURL(&url))
     return GURL();
   return url;
 }
 
 std::wstring UITest::GetActiveTabTitle(int window_index) {
   std::wstring title;
-  scoped_ptr<TabProxy> tab_proxy(GetActiveTab(window_index));
+  scoped_refptr<TabProxy> tab_proxy(GetActiveTab(window_index));
   if (!tab_proxy.get())
     return title;
 
   EXPECT_TRUE(tab_proxy->GetTabTitle(&title));
   return title;
 }
 
 int UITest::GetActiveTabIndex(int window_index) {
-  scoped_ptr<TabProxy> tab_proxy(GetActiveTab(window_index));
+  scoped_refptr<TabProxy> tab_proxy(GetActiveTab(window_index));
   if (!tab_proxy.get())
     return -1;
 
   int index;
   EXPECT_TRUE(tab_proxy->GetTabIndex(&index));
   return index;
 }
 
 bool UITest::IsBrowserRunning() {
   return CrashAwareSleep(0);
@@ skipping 33 matching lines @@
 DictionaryValue* UITest::GetDefaultProfilePreferences() {
   std::wstring path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   file_util::AppendToPath(&path, chrome::kNotSignedInProfile);
   file_util::AppendToPath(&path, chrome::kPreferencesFilename);
   return LoadDictionaryValueFromPath(FilePath::FromWStringHack(path));
 }
 #endif  // OS_WIN
 
 int UITest::GetTabCount() {
-  scoped_ptr<BrowserProxy> first_window(automation()->GetBrowserWindow(0));
+  scoped_refptr<BrowserProxy> first_window(automation()->GetBrowserWindow(0));
   if (!first_window.get())
     return 0;
 
   int result = 0;
   EXPECT_TRUE(first_window->GetTabCount(&result));
 
   return result;
 }
 
 bool UITest::WaitUntilCookieValue(TabProxy* tab,
@@ skipping 83 matching lines @@
 void UITest::WaitUntilTabCount(int tab_count) {
   for (int i = 0; i < 10; ++i) {
     PlatformThread::Sleep(sleep_timeout_ms() / 10);
     if (GetTabCount() == tab_count)
       break;
   }
   EXPECT_EQ(tab_count, GetTabCount());
 }
 
 std::wstring UITest::GetDownloadDirectory() {
-  scoped_ptr<TabProxy> tab_proxy(GetActiveTab());
+  scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
   if (!tab_proxy.get())
     return false;
 
   std::wstring download_directory;
   EXPECT_TRUE(tab_proxy->GetDownloadDirectory(&download_directory));
   return download_directory;
 }
 
 void UITest::CloseBrowserAsync(BrowserProxy* browser) const {
   server_->Send(
@@ skipping 43 matching lines @@
   // which signals completion of the test.  The cookie name is
   // a concatenation of the test name and the test id.  This allows
   // us to run multiple tests within a single webpage and test
   // that they all c
   std::string cookie_name = name;
   cookie_name.append(".");
   cookie_name.append(id);
   cookie_name.append(".");
   cookie_name.append(test_complete_cookie);
 
-  scoped_ptr<TabProxy> tab(GetActiveTab());
+  scoped_refptr<TabProxy> tab(GetActiveTab());
 
   bool test_result = WaitUntilCookieValue(tab.get(), url,
                                           cookie_name.c_str(),
                                           kIntervalMilliSeconds, wait_time,
                                           expected_cookie_value.c_str());
   EXPECT_EQ(true, test_result);
 }
 
 void UITest::PrintResult(const std::string& measurement,
                          const std::string& modifier,
@@ skipping 53 matching lines @@
 }
 
 bool UITest::EvictFileFromSystemCacheWrapper(const FilePath& path) {
   for (int i = 0; i < 10; i++) {
     if (file_util::EvictFileFromSystemCache(path))
       return true;
     PlatformThread::Sleep(sleep_timeout_ms() / 10);
   }
   return false;
 }