Add named testing interface

chrome/browser/ui/browser_init.cc

 // 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.
 
 #include "chrome/browser/ui/browser_init.h"
 
 #include <algorithm>   // For max().
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 955 matching lines @@
       if (command_line.HasSwitch(switches::kNoStartupWindow)) {
         expected_tab_count = 0;
       } else if (command_line.HasSwitch(switches::kRestoreLastSession)) {
         std::string restore_session_value(
             command_line.GetSwitchValueASCII(switches::kRestoreLastSession));
         base::StringToInt(restore_session_value, &expected_tab_count);
       } else {
         expected_tab_count =
             std::max(1, static_cast<int>(command_line.args().size()));
       }
-      CreateAutomationProvider<TestingAutomationProvider>(
+      if (!CreateAutomationProvider<TestingAutomationProvider>(
           testing_channel_id,
           profile,
-          static_cast<size_t>(expected_tab_count));
+          static_cast<size_t>(expected_tab_count)))
+        return false;
     }
   }
 
   bool silent_launch = false;
 
   if (command_line.HasSwitch(switches::kAutomationClientChannelID)) {
     std::string automation_channel_id = command_line.GetSwitchValueASCII(
         switches::kAutomationClientChannelID);
     // If there are any extra parameters, we expect each one to generate a
     // new tab; if there are none then we have no tabs
     size_t expected_tabs =
         std::max(static_cast<int>(command_line.args().size()), 0);
     if (expected_tabs == 0)
       silent_launch = true;
 
     if (command_line.HasSwitch(switches::kChromeFrame)) {
-      CreateAutomationProvider<ChromeFrameAutomationProvider>(
-          automation_channel_id, profile, expected_tabs);
+      if (!CreateAutomationProvider<ChromeFrameAutomationProvider>(
+          automation_channel_id, profile, expected_tabs))
+        return false;
     } else {
-      CreateAutomationProvider<AutomationProvider>(automation_channel_id,
-                                                   profile, expected_tabs);
+      if (!CreateAutomationProvider<AutomationProvider>(
+          automation_channel_id, profile, expected_tabs))
+        return false;
     }
   }
 
   // If we have been invoked to display a desktop notification on behalf of
   // the service process, we do not want to open any browser windows.
   if (command_line.HasSwitch(switches::kNotifyCloudPrintTokenExpired)) {
     silent_launch = true;
     profile->GetCloudPrintProxyService()->ShowTokenExpiredNotification();
   }
 
@@ skipping 38 matching lines @@
   // If we don't want to launch a new browser window or tab (in the case
   // of an automation request), we are done here.
   if (!silent_launch) {
     return browser_init->LaunchBrowser(
         command_line, profile, cur_dir, process_startup, return_code);
   }
   return true;
 }
 
 template <class AutomationProviderClass>
-void BrowserInit::CreateAutomationProvider(const std::string& channel_id,
+bool BrowserInit::CreateAutomationProvider(const std::string& channel_id,
                                            Profile* profile,
                                            size_t expected_tabs) {
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
-  automation->ConnectToChannel(channel_id);
+
+  if (!automation->InitializeChannel(channel_id))
+    return false;
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list =
       g_browser_process->InitAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
+
+  return true;
 }