Allow proxy channels to be created without initializing the underlying channel.

chrome/test/automation/automation_proxy.cc

 // Copyright (c) 2011 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 143 matching lines @@
 }
 
 void AutomationProxy::InitializeChannel(const std::string& channel_id,
                                         bool use_named_interface) {
   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.
-  IPC::Channel::Mode mode =
+  channel_.reset(new IPC::SyncChannel(
+      this,  // we are the listener
+      thread_->message_loop_proxy(),
+      shutdown_event_.get()));
+  channel_->AddFilter(new AutomationMessageFilter(this));
+
+  // Create the pipe synchronously so that Chrome doesn't try to connect to an
+  // unready server. Note this is done after adding a message filter to
+  // guarantee that it doesn't miss any messages when we are the client.
+  // See crbug.com/102894.
+  channel_->Init(
+      channel_id,
       use_named_interface ? IPC::Channel::MODE_NAMED_CLIENT
-                          : IPC::Channel::MODE_SERVER;
-  // Create the pipe immediately if we are serving, so that Chrome doesn't try
-  // to connect an unready server. Create it asynchronously if we are the
-  // client, otherwise the filter may not be in place before Chrome sends
-  // the first automation Hello message.
-  bool create_pipe_now = mode & IPC::Channel::MODE_SERVER_FLAG;
-  channel_.reset(new IPC::SyncChannel(
-    channel_id,
-    mode,
-    this,  // we are the listener
-    thread_->message_loop_proxy(),
-    create_pipe_now,
-    shutdown_event_.get()));
-  channel_->AddFilter(new AutomationMessageFilter(this));
+                          : IPC::Channel::MODE_SERVER,
+      true /* create_pipe_now */);
 }
 
 void AutomationProxy::InitializeHandleTracker() {
   tracker_.reset(new AutomationHandleTracker());
 }
 
 AutomationLaunchResult AutomationProxy::WaitForAppLaunch() {
   AutomationLaunchResult result = AUTOMATION_SUCCESS;
   if (app_launched_.TimedWait(action_timeout_)) {
     if (server_version_ == kChannelErrorVersionString) {
@@ skipping 400 matching lines @@
 }
 
 bool AutomationProxy::SendJSONRequest(const std::string& request,
                                       int timeout_ms,
                                       std::string* response) {
   bool result = false;
   if (!SendAutomationJSONRequest(this, request, timeout_ms, response, &result))
     return false;
   return result;
 }