Remove the NaCl SRPC proxy from Chrome.

chrome/browser/nacl_host/nacl_process_host.cc

 // Copyright (c) 2012 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/nacl_host/nacl_process_host.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 150 matching lines @@
       reply_msg_(NULL),
 #if defined(OS_WIN)
       debug_exception_handler_requested_(false),
 #endif
       internal_(new NaClInternal()),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       enable_exception_handling_(false),
       enable_debug_stub_(false),
       uses_irt_(uses_irt),
       off_the_record_(off_the_record),
-      enable_ipc_proxy_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ipc_plugin_listener_(this)),
       render_view_id_(render_view_id) {
   process_.reset(content::BrowserChildProcessHost::Create(
       content::PROCESS_TYPE_NACL_LOADER, this));
 
   // Set the display name so the user knows what plugin the process is running.
   // We aren't on the UI thread so getting the pref locale for language
   // formatting isn't possible, so IDN will be lost, but this is probably OK
   // for this use case.
   process_->SetName(net::FormatUrl(manifest_url_, std::string()));
 
   // We allow untrusted hardware exception handling to be enabled via
   // an env var for consistency with the standalone build of NaCl.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableNaClExceptionHandling) ||
       getenv("NACL_UNTRUSTED_EXCEPTION_HANDLING") != NULL) {
     enable_exception_handling_ = true;
   }
   enable_debug_stub_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableNaClDebug);
-
-  enable_ipc_proxy_ = !CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableNaClSRPCProxy);
-  // If render_view_id == 0 we do not need PPAPI, so we can skip
-  // PPAPI IPC proxy channel creation, etc.
-  if (!render_view_id_)
-    enable_ipc_proxy_ = false;
 }
 
 NaClProcessHost::~NaClProcessHost() {
   int exit_code;
   process_->GetTerminationStatus(&exit_code);
   std::string message =
       base::StringPrintf("NaCl process exited with status %i (0x%x)",
                          exit_code, exit_code);
   if (exit_code == 0) {
     LOG(INFO) << message;
@@ skipping 491 matching lines @@
 bool NaClProcessHost::StartNaClExecution() {
   NaClBrowser* nacl_browser = NaClBrowser::GetInstance();
 
   nacl::NaClStartParams params;
   params.validation_cache_enabled = nacl_browser->ValidationCacheIsEnabled();
   params.validation_cache_key = nacl_browser->GetValidationCacheKey();
   params.version = chrome::VersionInfo().CreateVersionString();
   params.enable_exception_handling = enable_exception_handling_;
   params.enable_debug_stub = enable_debug_stub_ &&
       NaClBrowser::GetInstance()->URLMatchesDebugPatterns(manifest_url_);
-  params.enable_ipc_proxy = enable_ipc_proxy_;
+  // Enable PPAPI proxy channel creation only for renderer processes.
+  params.enable_ipc_proxy = enable_ppapi_proxy();
   params.uses_irt = uses_irt_;
 
   const ChildProcessData& data = process_->GetData();
   if (!ShareHandleToSelLdr(data.handle,
                            internal_->socket_for_sel_ldr, true,
                            &params.handles)) {
     return false;
   }
 
   if (params.uses_irt) {
@@ skipping 38 matching lines @@
   }
 #endif
 
   process_->Send(new NaClProcessMsg_Start(params));
 
   internal_->socket_for_sel_ldr = nacl::kInvalidHandle;
   return true;
 }
 
 bool NaClProcessHost::SendStart() {
-  if (!enable_ipc_proxy_) {
+  if (!enable_ppapi_proxy()) {
     if (!ReplyToRenderer(IPC::ChannelHandle()))
       return false;
   }
   return StartNaClExecution();
 }
 
 // This method is called when NaClProcessHostMsg_PpapiChannelCreated is
 // received or PpapiHostMsg_ChannelCreated is forwarded by our plugin
 // listener.
 void NaClProcessHost::OnPpapiChannelCreated(
     const IPC::ChannelHandle& channel_handle) {
-  DCHECK(enable_ipc_proxy_);
+  // Only renderer processes should create a channel.
+  DCHECK(enable_ppapi_proxy());
   // If the proxy channel is null, this must be the initial NaCl-Browser IPC
   // channel.
   if (!ipc_proxy_channel_.get()) {
     ipc_proxy_channel_.reset(
         new IPC::ChannelProxy(channel_handle,
                               IPC::Channel::MODE_CLIENT,
                               &ipc_plugin_listener_,
                               base::MessageLoopProxy::current()));
     // Create the browser ppapi host and enable PPAPI message dispatching to the
     // browser process.
@@ skipping 135 matching lines @@
   } else {
     NaClStartDebugExceptionHandlerThread(
         process_handle.Take(), info,
         base::MessageLoopProxy::current(),
         base::Bind(&NaClProcessHost::OnDebugExceptionHandlerLaunchedByBroker,
                    weak_factory_.GetWeakPtr()));
     return true;
   }
 }
 #endif