Remove the Remoting Host component from Chrome.

chrome/browser/service/service_process_control.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/browser/service/service_process_control.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/process_util.h"
 #include "base/stl_util-inl.h"
@@ skipping 169 matching lines @@
 
   // We don't need the launcher anymore.
   launcher_ = NULL;
 }
 
 bool ServiceProcessControl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceProcessControl, message)
     IPC_MESSAGE_HANDLER(ServiceHostMsg_CloudPrintProxy_IsEnabled,
                         OnCloudPrintProxyIsEnabled)
-    IPC_MESSAGE_HANDLER(ServiceHostMsg_RemotingHost_HostInfo,
-                         OnRemotingHostInfo)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceProcessControl::OnChannelConnected(int32 peer_pid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   channel_->set_sync_messages_with_no_timeout_allowed(false);
 
   // We just established a channel with the service process. Notify it if an
@@ skipping 32 matching lines @@
 
 void ServiceProcessControl::OnCloudPrintProxyIsEnabled(bool enabled,
                                                        std::string email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (cloud_print_status_callback_ != NULL) {
     cloud_print_status_callback_->Run(enabled, email);
     cloud_print_status_callback_.reset();
   }
 }
 
-void ServiceProcessControl::OnRemotingHostInfo(
-    const remoting::ChromotingHostInfo& host_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  for (std::set<MessageHandler*>::iterator it = message_handlers_.begin();
-       it != message_handlers_.end(); ++it) {
-    (*it)->OnRemotingHostInfo(host_info);
-  }
-}
-
 bool ServiceProcessControl::GetCloudPrintProxyStatus(
     Callback2<bool, std::string>::Type* cloud_print_status_callback) {
   DCHECK(cloud_print_status_callback);
   cloud_print_status_callback_.reset(cloud_print_status_callback);
   return Send(new ServiceMsg_IsCloudPrintProxyEnabled);
 }
 
 bool ServiceProcessControl::Shutdown() {
   bool ret = Send(new ServiceMsg_Shutdown());
   channel_.reset();
   return ret;
 }
 
-bool ServiceProcessControl::SetRemotingHostCredentials(
-    const std::string& user,
-    const std::string& talk_token) {
-  return Send(
-      new ServiceMsg_SetRemotingHostCredentials(user, talk_token));
-}
-
-bool ServiceProcessControl::EnableRemotingHost() {
-  return Send(new ServiceMsg_EnableRemotingHost());
-}
-
-bool ServiceProcessControl::DisableRemotingHost() {
-  return Send(new ServiceMsg_DisableRemotingHost());
-}
-
-bool ServiceProcessControl::RequestRemotingHostStatus() {
-  if (CheckServiceProcessReady()) {
-    remoting::ChromotingHostInfo failure_host_info;
-    failure_host_info.enabled = false;
-
-    Launch(NewRunnableMethod(this, &ServiceProcessControl::Send,
-                             new ServiceMsg_GetRemotingHostInfo),
-           NewRunnableMethod(this,
-                             &ServiceProcessControl::OnRemotingHostInfo,
-                             failure_host_info));
-    return true;
-  }
-  return false;
-}
-
-void ServiceProcessControl::AddMessageHandler(
-    MessageHandler* message_handler) {
-  message_handlers_.insert(message_handler);
-}
-
-void ServiceProcessControl::RemoveMessageHandler(
-    MessageHandler* message_handler) {
-  message_handlers_.erase(message_handler);
-}
-
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ServiceProcessControl);
 
 ServiceProcessControl::Launcher::Launcher(ServiceProcessControl* process,
                                           CommandLine* cmd_line)
     : process_(process),
       cmd_line_(cmd_line),
       launched_(false),
       retry_count_(0) {
 }
 
@@ skipping 40 matching lines @@
   if (base::LaunchApp(*cmd_line_, false, true, NULL)) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             NewRunnableMethod(this,
                                               &Launcher::DoDetectLaunched));
   } else {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             NewRunnableMethod(this, &Launcher::Notify));
   }
 }
 #endif  // !OS_MACOSX