Pass a DesktopEnvironmentFactory when creating DesktopProcess.

remoting/host/desktop_process_unittest.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 "remoting/host/desktop_process.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
+#include "media/video/capture/screen/screen_capturer_fake.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_process.h"
 #include "remoting/host/host_exit_codes.h"
+#include "remoting/host/host_mock_objects.h"
+#include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::AnyNumber;
 using testing::InSequence;
+using testing::Return;
 
 namespace remoting {
 
 namespace {
 
 class MockDaemonListener : public IPC::Listener {
  public:
   MockDaemonListener() {}
   virtual ~MockDaemonListener() {}
 
@@ skipping 51 matching lines @@
   virtual ~DesktopProcessTest();
 
   // testing::Test overrides
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   // MockDaemonListener mocks
   void ConnectNetworkChannel(IPC::PlatformFileForTransit desktop_process);
   void OnDesktopAttached(IPC::PlatformFileForTransit desktop_process);
 
+  // Creates a DesktopEnvironment with a fake media::ScreenCapturer, to mock
+  // DesktopEnvironmentFactory::Create().
+  DesktopEnvironment* CreateDesktopEnvironment();
+
+  // Creates a dummy EventExecutor, to mock
+  // DesktopEnvironment::CreateEventExecutor().
+  EventExecutor* CreateEventExecutor();
+
+  // Creates a fake media::ScreenCapturer, to mock
+  // DesktopEnvironment::CreateVideoCapturer().
+  media::ScreenCapturer* CreateVideoCapturer();
+
   // Disconnects the daemon-to-desktop channel causing the desktop process to
   // exit.
   void DisconnectChannels();
 
   // Runs the desktop process code in a separate thread.
   void RunDesktopProcess();
 
   // Creates the desktop process and sends a crash request to it.
   void RunDeathTest();
 
@@ skipping 51 matching lines @@
 
 void DesktopProcessTest::OnDesktopAttached(
     IPC::PlatformFileForTransit desktop_process) {
 #if defined(OS_POSIX)
     DCHECK(desktop_process.auto_close);
 
     base::ClosePlatformFile(desktop_process.fd);
 #endif  // defined(OS_POSIX)
 }
 
+DesktopEnvironment* DesktopProcessTest::CreateDesktopEnvironment() {
+  MockDesktopEnvironment* desktop_environment = new MockDesktopEnvironment();
+  EXPECT_CALL(*desktop_environment, CreateAudioCapturerPtr(_))
+      .Times(0);
+  EXPECT_CALL(*desktop_environment, CreateEventExecutorPtr(_, _))
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          InvokeWithoutArgs(this, &DesktopProcessTest::CreateEventExecutor));
+  EXPECT_CALL(*desktop_environment, CreateVideoCapturerPtr(_, _))
+      .Times(AnyNumber())
+      .WillRepeatedly(
+          InvokeWithoutArgs(this, &DesktopProcessTest::CreateVideoCapturer));

[Wez, 2013/02/01 01:02:11]

This will end up adding expectations after the test has started running code,
which isn't normally safe in gmock - you may have to switch to using a full fake
implementation here. :(

[alexeypa (please no reviews), 2013/02/01 17:28:43]

We use this pattern (create a new object and set a bunch of expectations - all
on the main thread) in many places. |g_gmock_mutex| is taken when expectations
are set/checked. It appears to be safe enough to create expectations on-the-fly
(on a newly created object).

[Wez, 2013/02/01 17:30:24]

Yes, I think that the newly-created-object aspect is the key thing. Cool.

+

[Wez, 2013/02/01 01:02:11]

nit: Don't really need a blank line here.

[alexeypa (please no reviews), 2013/02/01 17:28:43]

Done.

+  return desktop_environment;
+}
+
+EventExecutor* DesktopProcessTest::CreateEventExecutor() {
+  MockEventExecutor* event_executor = new MockEventExecutor();
+  EXPECT_CALL(*event_executor, StartPtr(_));
+  return event_executor;
+}
+
+media::ScreenCapturer* DesktopProcessTest::CreateVideoCapturer() {
+  return new media::ScreenCapturerFake();
+}
+
 void DesktopProcessTest::DisconnectChannels() {
   daemon_channel_.reset();
   network_channel_.reset();
   io_task_runner_ = NULL;
 }
 
 void DesktopProcessTest::RunDesktopProcess() {
   base::RunLoop run_loop;
   base::Closure quit_ui_task_runner = base::Bind(
       base::IgnoreResult(&base::SingleThreadTaskRunner::PostTask),
       message_loop_.message_loop_proxy(),
       FROM_HERE, run_loop.QuitClosure());
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner = new AutoThreadTaskRunner(
       message_loop_.message_loop_proxy(), quit_ui_task_runner);
 
   io_task_runner_ = AutoThread::CreateWithType("IPC thread", ui_task_runner,
                                                MessageLoop::TYPE_IO);
 
   std::string channel_name = IPC::Channel::GenerateUniqueRandomChannelID();
   daemon_channel_.reset(new IPC::ChannelProxy(
       IPC::ChannelHandle(channel_name),
       IPC::Channel::MODE_SERVER,
       &daemon_listener_,
       io_task_runner_));
 
+  scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory(
+      new MockDesktopEnvironmentFactory());
+  EXPECT_CALL(*desktop_environment_factory, CreatePtr())
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke(this,
+                             &DesktopProcessTest::CreateDesktopEnvironment));
+  EXPECT_CALL(*desktop_environment_factory, SupportsAudioCapture())
+      .Times(AnyNumber())
+      .WillRepeatedly(Return(false));
+
   DesktopProcess desktop_process(ui_task_runner, channel_name);
-  EXPECT_TRUE(desktop_process.Start());
+  EXPECT_TRUE(desktop_process.Start(
+      desktop_environment_factory.PassAs<DesktopEnvironmentFactory>()));
 
   ui_task_runner = NULL;
   run_loop.Run();
 }
 
 void DesktopProcessTest::RunDeathTest() {
   InSequence s;
   EXPECT_CALL(daemon_listener_, OnChannelConnected(_));
   EXPECT_CALL(daemon_listener_, OnDesktopAttached(_))
       .WillOnce(DoAll(
@@ skipping 35 matching lines @@
 }
 
 // Run the desktop process and ask it to crash.
 TEST_F(DesktopProcessTest, DeathTest) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
 
   EXPECT_DEATH(RunDeathTest(), "");
 }
 
 }  // namespace remoting