Add named testing interface

chrome/test/ui/ui_test.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_TEST_UI_UI_TEST_H_
 #define CHROME_TEST_UI_UI_TEST_H_
 #pragma once
 
 // This file provides a common base for running UI unit tests, which operate
 // the entire browser application in a separate process for holistic
@@ skipping 20 matching lines @@
 // AutomationProxy here, but many files that #include this one don't
 // themselves #include automation_proxy.h.
 #include "chrome/test/automation/automation_proxy.h"
 #include "testing/platform_test.h"
 
 class AutomationProxy;
 class BrowserProxy;
 class DictionaryValue;
 class FilePath;
 class GURL;
+class ProxyLauncher;
 class ScopedTempDir;
 class TabProxy;
 
 // Base class for UI Tests. This implements the core of the functions.
 // This base class decouples all automation functionality from testing
 // infrastructure, for use without gtest.
 // If using gtest, you probably want to inherit from UITest (declared below)
 // rather than UITestBase.
 class UITestBase {
  protected:
@@ skipping 10 matching lines @@
   // Starts the browser using the arguments in launch_arguments_, and
   // sets up member variables.
   virtual void SetUp();
 
   // Closes the browser window.
   virtual void TearDown();
 
  public:
   // ********* Utility functions *********
 
-  // Launches the browser and IPC testing server.
+  // Launches the browser and IPC testing connection in server mode.
   void LaunchBrowserAndServer();
 
+  // Launches the IPC testing connection in client mode,
+  // which then attempts to connect to a browser.
+  void ConnectToRunningBrowser();
+
   // Only for pyauto.
   void set_command_execution_timeout_ms(int timeout);
 
-  // Overridable so that derived classes can provide their own AutomationProxy.
-  virtual AutomationProxy* CreateAutomationProxy(int execution_timeout);
+  // Overridable so that derived classes can provide their own ProxyLauncher.
+  virtual ProxyLauncher* CreateProxyLauncher();
 
   // Closes the browser and IPC testing server.
   void CloseBrowserAndServer();
 
   // Launches the browser with the given command line.
   // TODO(phajdan.jr): Make LaunchBrowser private. Tests should use
   // LaunchAnotherBrowserBlockUntilClosed.
   void LaunchBrowser(const CommandLine& cmdline, bool clear_profile);
 
 #if !defined(OS_MACOSX)
   // This function is deliberately not defined on the Mac because re-using an
   // existing browser process when launching from the command line isn't a
   // concept that we support on the Mac; AppleEvents are the Mac solution for
   // the same need. Any test based on this function doesn't apply to the Mac.
 
   // Launches an another browser process and waits for it to finish. Returns
   // true on success.
   bool LaunchAnotherBrowserBlockUntilClosed(const CommandLine& cmdline);
 #endif
 
   // Exits out browser instance.
   void QuitBrowser();
 
   // Terminates the browser, simulates end of session.
   void TerminateBrowser();
 
-  // Tells the browser to navigato to the givne URL in the active tab
+  // Tells the browser to navigate to the given URL in the active tab
   // of the first app window.
   // Does not wait for the navigation to complete to return.
   void NavigateToURLAsync(const GURL& url);
 
   // Tells the browser to navigate to the given URL in the active tab
   // of the first app window.
   // This method doesn't return until the navigation is complete.
   void NavigateToURL(const GURL& url);
 
   // Same as above, except in the given tab and window.
@@ skipping 238 matching lines @@
   // Use Chromium binaries from the given directory.
   void SetBrowserDirectory(const FilePath& dir);
 
  private:
   // Check that no processes related to Chrome exist, displaying
   // the given message if any do.
   void AssertAppNotRunning(const std::wstring& error_message);
 
  protected:
   AutomationProxy* automation() {
-    EXPECT_TRUE(server_.get());
-    return server_.get();
+    EXPECT_TRUE(automation_proxy_.get());
+    return automation_proxy_.get();
   }
 
   virtual bool ShouldFilterInet() {
     return true;
   }
 
   // Wait a certain amount of time for all the app processes to exit,
   // forcibly killing them if they haven't exited by then.
   // It has the side-effect of killing every browser window opened in your
   // session, even those unrelated in the test.
@@ skipping 29 matching lines @@
   base::ProcessId process_id_;          // PID of |process_| (for debugging).
   static bool in_process_renderer_;     // true if we're in single process mode
   bool show_window_;                    // Determines if the window is shown or
                                         // hidden. Defaults to hidden.
   bool clear_profile_;                  // If true the profile is cleared before
                                         // launching. Default is true.
   bool include_testing_id_;             // Should we supply the testing channel
                                         // id on the command line? Default is
                                         // true.
   bool enable_file_cookies_;            // Enable file cookies, default is true.
+  scoped_ptr<ProxyLauncher> launcher_;  // Launches browser and AutomationProxy.
   ProfileType profile_type_;            // Are we using a profile with a
                                         // complex theme?
   FilePath websocket_pid_file_;         // PID file for websocket server.
   ShutdownType shutdown_type_;          // The method for shutting down
                                         // the browser. Used in ShutdownTest.
 
  private:
+  void WaitForBrowserLaunch();
+
   bool LaunchBrowserHelper(const CommandLine& arguments,
                            bool wait,
                            base::ProcessHandle* process);
 
   // We want to have a current history database when we start the browser so
   // things like the NTP will have thumbnails.  This method updates the dates
   // in the history to be more recent.
   void UpdateHistoryDates();
 
   base::Time test_start_time_;          // Time the test was started
                                         // (so we can check for new crash dumps)
   static bool no_sandbox_;
   static bool safe_plugins_;
   static bool full_memory_dump_;        // If true, write full memory dump
                                         // during crash.
   static bool show_error_dialogs_;      // If true, a user is paying attention
                                         // to the test, so show error dialogs.
   static bool dump_histograms_on_exit_;  // Include histograms in log on exit.
   static bool enable_dcheck_;           // Enable dchecks in release mode.
   static bool silent_dump_on_dcheck_;   // Dump process memory on dcheck without
                                         // crashing.
   static bool disable_breakpad_;        // Disable breakpad on the browser.
   static int timeout_ms_;               // Timeout in milliseconds to wait
                                         // for an test to finish.
   static std::string js_flags_;         // Flags passed to the JS engine.
   static std::string log_level_;        // Logging level.
 
-  scoped_ptr<AutomationProxy> server_;
+  scoped_ptr<AutomationProxy> automation_proxy_;
 
   std::string ui_test_name_;
 
   // We use a temporary directory for profile to avoid issues with being
   // unable to delete some files because they're in use, etc.
   scoped_ptr<ScopedTempDir> temp_profile_dir_;
 };
 
 class UITest : public UITestBase, public PlatformTest {
  protected:
   UITest() {}
   explicit UITest(MessageLoop::Type msg_loop_type)
     : UITestBase(), PlatformTest(), message_loop_(msg_loop_type) {
   }
   virtual void SetUp();
   virtual void TearDown();
 
-  virtual AutomationProxy* CreateAutomationProxy(int execution_timeout);
+  virtual ProxyLauncher* CreateProxyLauncher();
 
   // Synchronously launches local http server normally used to run LayoutTests.
   void StartHttpServer(const FilePath& root_directory);
 
   // Launches local http server on the specified port.
   void StartHttpServerWithPort(const FilePath& root_directory, int port);
 
   void StopHttpServer();
 
   // Count the number of active browser processes launched by this test.
@@ skipping 97 matching lines @@
 #ifdef UNIT_TEST
 std::ostream& operator<<(std::ostream& out, const std::wstring& wstr);
 
 template<typename T>
 std::ostream& operator<<(std::ostream& out, const ::scoped_ptr<T>& ptr) {
   return out << ptr.get();
 }
 #endif  // UNIT_TEST
 
 #endif  // CHROME_TEST_UI_UI_TEST_H_