Tiny little refactoring of DesktopEnvironment.

remoting/host/host_mock_objects.h

 // 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.
 
 #ifndef REMOTING_HOST_HOST_MOCK_OBJECTS_H_
 #define REMOTING_HOST_HOST_MOCK_OBJECTS_H_
 
 #include "net/base/ip_endpoint.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/continue_window.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/desktop_environment_factory.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/ui_strings.h"
 #include "remoting/proto/control.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace remoting {
 
+class MockDesktopEnvironment : public DesktopEnvironment {
+ public:
+  MockDesktopEnvironment();
+  virtual ~MockDesktopEnvironment();
+
+  // protocol::ClipboardStub implementation.
+  MOCK_METHOD1(InjectClipboardEvent, void(const protocol::ClipboardEvent&));
+
+  // protocol::InputStub implementation.
+  MOCK_METHOD1(InjectKeyEvent, void(const protocol::KeyEvent&));
+  MOCK_METHOD1(InjectMouseEvent, void(const protocol::MouseEvent&));
+
+  // DesktopEnvironment implementation.
+  MOCK_METHOD3(StartAudioPtr, void(
+      scoped_refptr<base::SingleThreadTaskRunner>,
+      AudioEncoder*,
+      protocol::AudioStub*));
+  MOCK_METHOD1(PauseAudio, void(bool));
+  MOCK_METHOD3(StartInput, void(
+      scoped_refptr<base::SingleThreadTaskRunner>,
+      scoped_refptr<base::SingleThreadTaskRunner>,
+      protocol::ClipboardStub*));
+  MOCK_METHOD5(StartVideoPtr, void(
+      scoped_refptr<base::SingleThreadTaskRunner>,
+      scoped_refptr<base::SingleThreadTaskRunner>,
+      VideoEncoder*,
+      protocol::CursorShapeStub*,
+      protocol::VideoStub*));
+  MOCK_CONST_METHOD0(GetScreenSize, SkISize());
+  MOCK_METHOD1(PauseVideo, void(bool));
+  MOCK_METHOD1(UpdateSequenceNumber, void(int64));
+
+  virtual void StartAudio(
+      scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+      scoped_ptr<AudioEncoder> audio_encoder,
+      protocol::AudioStub* audio_stub) OVERRIDE;
+  virtual void StartVideo(
+      scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
+      scoped_ptr<VideoEncoder> video_encoder,
+      protocol::CursorShapeStub* cursor_shape_stub,
+      protocol::VideoStub* video_stub) OVERRIDE;
+};
+
 class MockDisconnectWindow : public DisconnectWindow {
  public:
   MockDisconnectWindow();
   virtual ~MockDisconnectWindow();
 
   MOCK_METHOD3(Show, bool(const UiStrings& ui_strings,
                           const base::Closure& disconnect_callback,
                           const std::string& username));
   MOCK_METHOD0(Hide, void());
 };
@@ skipping 36 matching lines @@
       const protocol::TransportRoute& route));
   MOCK_METHOD2(OnClientDimensionsChanged, void(ClientSession* client,
                                                const SkISize& size));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockClientSessionEventHandler);
 };
 
 class MockDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
  public:
-  MockDesktopEnvironmentFactory();
+  explicit MockDesktopEnvironmentFactory(
+      scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner);
   virtual ~MockDesktopEnvironmentFactory();
 
   MOCK_METHOD0(CreatePtr, DesktopEnvironment*());
 
-  virtual scoped_ptr<DesktopEnvironment> Create() OVERRIDE;
+  virtual scoped_ptr<DesktopEnvironment> Create(
+      const std::string& client_jid,
+      const base::Closure& disconnect_callback) OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDesktopEnvironmentFactory);
 };
 
 class MockEventExecutor : public EventExecutor {
  public:
   MockEventExecutor();
   virtual ~MockEventExecutor();
 
@@ skipping 23 matching lines @@
                void(const std::string& jid,
                     const std::string& channel_name,
                     const protocol::TransportRoute& route));
   MOCK_METHOD1(OnStart, void(const std::string& xmpp_login));
   MOCK_METHOD0(OnShutdown, void());
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_HOST_MOCK_OBJECTS_H_