Revert "Add named testing interface."

chrome/browser/automation/automation_provider.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/automation/automation_provider.h"
 
 #include <set>
 
 #include "app/message_box_flags.h"
 #include "base/callback.h"
@@ skipping 95 matching lines @@
 #include "webkit/glue/plugins/plugin_list.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/external_tab_container_win.h"
 #endif  // defined(OS_WIN)
 
 using base::Time;
 
 AutomationProvider::AutomationProvider(Profile* profile)
     : profile_(profile),
-      reply_message_(NULL),
-      is_connected_(false),
-      initial_loads_complete_(false) {
+      reply_message_(NULL) {
   TRACE_EVENT_BEGIN("AutomationProvider::AutomationProvider", 0, "");
 
   browser_tracker_.reset(new AutomationBrowserTracker(this));
   extension_tracker_.reset(new AutomationExtensionTracker(this));
   tab_tracker_.reset(new AutomationTabTracker(this));
   window_tracker_.reset(new AutomationWindowTracker(this));
   autocomplete_edit_tracker_.reset(
       new AutomationAutocompleteEditTracker(this));
   new_tab_ui_load_observer_.reset(new NewTabUILoadObserver(this));
   dom_operation_observer_.reset(new DomOperationMessageSender(this));
@@ skipping 15 matching lines @@
   NotificationObserver* observer;
   while ((observer = it.GetNext()) != NULL)
     delete observer;
 
   if (channel_.get()) {
     channel_->Close();
   }
   g_browser_process->ReleaseModule();
 }
 
-bool AutomationProvider::InitializeChannel(const std::string& channel_id) {
-  TRACE_EVENT_BEGIN("AutomationProvider::InitializeChannel", 0, "");
-
-  std::string effective_channel_id = channel_id;
-
-  // If the channel_id starts with kNamedInterfacePrefix, create a named IPC
-  // server and listen on it, else connect as client to an existing IPC server
-  bool use_named_interface =
-      channel_id.find(automation::kNamedInterfacePrefix) == 0;
-  if (use_named_interface) {
-    effective_channel_id = channel_id.substr(
-        strlen(automation::kNamedInterfacePrefix));
-    if (effective_channel_id.length() <= 0)
-      return false;
-  }
+void AutomationProvider::ConnectToChannel(const std::string& channel_id) {
+  TRACE_EVENT_BEGIN("AutomationProvider::ConnectToChannel", 0, "");
 
   if (!automation_resource_message_filter_.get()) {
     automation_resource_message_filter_ = new AutomationResourceMessageFilter;
   }
 
-  channel_.reset(new IPC::SyncChannel(
-      effective_channel_id,
-      use_named_interface ? IPC::Channel::MODE_NAMED_SERVER
-                          : IPC::Channel::MODE_CLIENT,
-      this,
-      g_browser_process->io_thread()->message_loop(),
-      true, g_browser_process->shutdown_event()));
+  channel_.reset(
+      new IPC::SyncChannel(channel_id, IPC::Channel::MODE_CLIENT, this,
+                           g_browser_process->io_thread()->message_loop(),
+                           true, g_browser_process->shutdown_event()));
   channel_->AddFilter(automation_resource_message_filter_);
 
-  TRACE_EVENT_END("AutomationProvider::InitializeChannel", 0, "");
+  // Send a hello message with our current automation protocol version.
+  channel_->Send(new AutomationMsg_Hello(0, GetProtocolVersion().c_str()));
 
-  return true;
+  TRACE_EVENT_END("AutomationProvider::ConnectToChannel", 0, "");
 }
 
 std::string AutomationProvider::GetProtocolVersion() {
   chrome::VersionInfo version_info;
   return version_info.Version().c_str();
 }
 
 void AutomationProvider::SetExpectedTabCount(size_t expected_tabs) {
-  if (expected_tabs == 0)
-    OnInitialLoadsComplete();
-  else
+  if (expected_tabs == 0) {
+    Send(new AutomationMsg_InitialLoadsComplete(0));
+  } else {
     initial_load_observer_.reset(new InitialLoadObserver(expected_tabs, this));
-}
-
-void AutomationProvider::OnInitialLoadsComplete() {
-  initial_loads_complete_ = true;
-  if (is_connected_)
-    Send(new AutomationMsg_InitialLoadsComplete(0));
+  }
 }
 
 NotificationObserver* AutomationProvider::AddNavigationStatusListener(
     NavigationController* tab, IPC::Message* reply_message,
     int number_of_navigations, bool include_current_navigation) {
   NotificationObserver* observer =
       new NavigationNotificationObserver(tab, this, reply_message,
                                          number_of_navigations,
                                          include_current_navigation);
 
@@ skipping 128 matching lines @@
   const Extension* extension =
       extension_tracker_->GetResource(extension_handle);
   ExtensionsService* service = profile_->GetExtensionsService();
   if (extension && service &&
       service->GetExtensionById(extension->id(), true) &&
       !service->GetExtensionById(extension->id(), false))
     return extension;
   return NULL;
 }
 
-void AutomationProvider::OnChannelConnected(int pid) {
-  is_connected_ = true;
-  LOG(INFO) << "Testing channel connected, sending hello message";
-
-  // Send a hello message with our current automation protocol version.
-  chrome::VersionInfo version_info;
-  channel_->Send(new AutomationMsg_Hello(0, version_info.Version()));
-  if (initial_loads_complete_)
-    Send(new AutomationMsg_InitialLoadsComplete(0));
-}
-
 void AutomationProvider::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(AutomationProvider, message)
 #if !defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowDrag,
                                     WindowSimulateDrag)
 #endif  // !defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(AutomationMsg_HandleUnused, HandleUnused)
     IPC_MESSAGE_HANDLER(AutomationMsg_SetProxyConfig, SetProxyConfig);
     IPC_MESSAGE_HANDLER(AutomationMsg_PrintAsync, PrintAsync)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_Find, HandleFindRequest)
@@ skipping 641 matching lines @@
     }
   }
 }
 
 void AutomationProvider::SaveAsAsync(int tab_handle) {
   NavigationController* tab = NULL;
   TabContents* tab_contents = GetTabContentsForHandle(tab_handle, &tab);
   if (tab_contents)
     tab_contents->OnSavePage();
 }