Move creation of capturer, input stub into ChromotingHost

remoting/host/simple_host_process.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.
 //
 // This is an application of a minimal host process in a Chromoting
 // system. It serves the purpose of gluing different pieces together
 // to make a functional host process for testing.
 //
 // It peforms the following functionality:
 // 1. Connect to the GTalk network and register the machine as a host.
@@ skipping 18 matching lines @@
 #include "base/thread.h"
 #include "media/base/media.h"
 #include "remoting/base/tracer.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/proto/video.pb.h"
 
 #if defined(OS_WIN)
-#include "remoting/host/capturer_gdi.h"
-#include "remoting/host/event_executor_win.h"
-#elif defined(OS_LINUX)
-#include "remoting/host/capturer_linux.h"
-#include "remoting/host/event_executor_linux.h"
-#elif defined(OS_MACOSX)
-#include "remoting/host/capturer_mac.h"
-#include "remoting/host/event_executor_mac.h"
-#endif
-
-#if defined(OS_WIN)
 const std::wstring kDefaultConfigPath = L".ChromotingConfig.json";
 const wchar_t kHomeDrive[] = L"HOMEDRIVE";
 const wchar_t kHomePath[] = L"HOMEPATH";
 const wchar_t* GetEnvironmentVar(const wchar_t* x) { return _wgetenv(x); }
 #else
 const std::string kDefaultConfigPath = ".ChromotingConfig.json";
 static char* GetEnvironmentVar(const char* x) { return getenv(x); }
 #endif
 
 void ShutdownTask(MessageLoop* message_loop) {
@@ skipping 10 matching lines @@
   CommandLine::Init(argc, argv);
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   base::AtExitManager exit_manager;
   base::EnsureNSPRInit();
 
   // Allocate a chromoting context and starts it.
   remoting::ChromotingHostContext context;
   context.Start();
 
-  scoped_ptr<remoting::Capturer> capturer;
-  scoped_ptr<remoting::protocol::InputStub> input_stub;
-#if defined(OS_WIN)
-  capturer.reset(new remoting::CapturerGdi(
-      context.capture_message_loop()));
-  input_stub.reset(new remoting::EventExecutorWin(
-      context.capture_message_loop(), capturer.get()));
-#elif defined(OS_LINUX)
-  capturer.reset(new remoting::CapturerLinux(
-      context.capture_message_loop()));
-  input_stub.reset(new remoting::EventExecutorLinux(
-      context.capture_message_loop(), capturer.get()));
-#elif defined(OS_MACOSX)
-  capturer.reset(new remoting::CapturerMac(
-      context.capture_message_loop()));
-  input_stub.reset(new remoting::EventExecutorMac(
-      context.capture_message_loop(), capturer.get()));
-#endif
-
-  // Check the argument to see if we should use a fake capturer.
-  bool fake = cmd_line->HasSwitch(kFakeSwitchName);
 
 #if defined(OS_WIN)
   std::wstring home_path = GetEnvironmentVar(kHomeDrive);
   home_path += GetEnvironmentVar(kHomePath);
 #else
   std::string home_path = GetEnvironmentVar(base::env_vars::kHome);
 #endif
   FilePath config_path(home_path);
   config_path = config_path.Append(kDefaultConfigPath);
   if (cmd_line->HasSwitch(kConfigSwitchName)) {
     config_path = cmd_line->GetSwitchValuePath(kConfigSwitchName);
   }
 
-  if (fake) {
-    // Inject a fake capturer.

[Sergey Ulanov, 2010/11/17 03:29:19]

Can you please not break fake capturer?

-    LOG(INFO) << "Using a fake capturer.";
-    capturer.reset(new remoting::CapturerFake(context.capture_message_loop()));
-  }
-
   base::Thread file_io_thread("FileIO");
   file_io_thread.Start();
 
   scoped_refptr<remoting::JsonHostConfig> config(
       new remoting::JsonHostConfig(
           config_path, file_io_thread.message_loop_proxy()));
 
   if (!config->Read()) {
     LOG(ERROR) << "Failed to read configuration file " << config_path.value();
     context.Stop();
     return 1;
   }
 
   FilePath module_path;
   PathService::Get(base::DIR_MODULE, &module_path);
   CHECK(media::InitializeMediaLibrary(module_path))
       << "Cannot load media library";
 
   // Construct a chromoting host.
   scoped_refptr<remoting::ChromotingHost> host(
-      new remoting::ChromotingHost(&context,
-                                   config,
-                                   capturer.release(),
-                                   input_stub.release()));
+      new remoting::ChromotingHost(&context, config));
 
   // Let the chromoting host run until the shutdown task is executed.
   MessageLoop message_loop(MessageLoop::TYPE_UI);
   host->Start(NewRunnableFunction(&ShutdownTask, &message_loop));
   message_loop.Run();
 
   // And then stop the chromoting context.
   context.Stop();
   file_io_thread.Stop();
   return 0;
 }