Revert "Add named testing interface."

chrome/test/automation/automation_proxy.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/test/automation/automation_proxy.h"
 
 #include <gtest/gtest.h>
 
 #include <sstream>
 
@@ skipping 89 matching lines @@
       perform_version_check_(false),
       disconnect_on_failure_(disconnect_on_failure),
       command_execution_timeout_(
           TimeDelta::FromMilliseconds(command_execution_timeout_ms)),
       listener_thread_id_(0) {
   // base::WaitableEvent::TimedWait() will choke if we give it a negative value.
   // Zero also seems unreasonable, since we need to wait for IPC, but at
   // least it is legal... ;-)
   DCHECK_GE(command_execution_timeout_ms, 0);
   listener_thread_id_ = PlatformThread::CurrentId();
+  InitializeChannelID();
   InitializeHandleTracker();
   InitializeThread();
+  InitializeChannel();
 }
 
 AutomationProxy::~AutomationProxy() {
   // Destruction order is important. Thread has to outlive the channel and
   // tracker has to outlive the thread since we access the tracker inside
   // AutomationMessageFilter::OnMessageReceived.
   Disconnect();
   thread_.reset();
   tracker_.reset();
 }
 
-std::string AutomationProxy::GenerateChannelID() {
+void AutomationProxy::InitializeChannelID() {
   // The channel counter keeps us out of trouble if we create and destroy
   // several AutomationProxies sequentially over the course of a test run.
   // (Creating the channel sometimes failed before when running a lot of
   // tests in sequence, and our theory is that sometimes the channel ID
   // wasn't getting freed up in time for the next test.)
   static int channel_counter = 0;
 
   std::ostringstream buf;
   buf << "ChromeTestingInterface:" << base::GetCurrentProcId() <<
          "." << ++channel_counter;
-  return buf.str();
+  channel_id_ = buf.str();
 }
 
 void AutomationProxy::InitializeThread() {
   scoped_ptr<base::Thread> thread(
       new base::Thread("AutomationProxy_BackgroundThread"));
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   bool thread_result = thread->StartWithOptions(options);
   DCHECK(thread_result);
   thread_.swap(thread);
 }
 
-void AutomationProxy::InitializeChannel(const std::string& channel_id,
-                                        bool use_named_interface) {
+void AutomationProxy::InitializeChannel() {
   DCHECK(shutdown_event_.get() != NULL);
 
   // TODO(iyengar)
   // The shutdown event could be global on the same lines as the automation
   // provider, where we use the shutdown event provided by the chrome browser
   // process.
   channel_.reset(new IPC::SyncChannel(
-    channel_id,
-    use_named_interface ? IPC::Channel::MODE_NAMED_CLIENT
-                        : IPC::Channel::MODE_SERVER,
+    channel_id_,
+    IPC::Channel::MODE_SERVER,
     this,  // we are the listener
     thread_->message_loop(),
     true,
     shutdown_event_.get()));
   channel_->AddFilter(new AutomationMessageFilter(this));
 }
 
 void AutomationProxy::InitializeHandleTracker() {
   tracker_.reset(new AutomationHandleTracker());
 }
@@ skipping 374 matching lines @@
                                                           password,
                                                           &success));
   // If message sending unsuccessful or test failed, return false.
   return sent && success;
 }
 #endif
 
 bool AutomationProxy::ResetToDefaultTheme() {
   return Send(new AutomationMsg_ResetToDefaultTheme(0));
 }