Speculative Revert 175648 on the branch to fix compilation failure.

> Connect to DesktopEnvironment's stubs only when audio/video schedulers are about to be created.
> 
> This CL localizes usage of DesktopEnvironment to a single method that creates audio/video schedulers and hook up the event executor. This prepares further refactoring of DesktopEnvironment that should become a factory for classes interacting with the specific desktop environment.
> 
> Related changes in this CL:
>   - MouseClampingFilter receives screen size on the proper thread.
>   - ClientSessionTest.* tests now run asynchronously to support MouseClampingFilter change.
>   - ClientSession does not expose DesktopEnvironment.
>   - InputEventTracker can be re-attached to a different InputStub.
> 
> BUG=104544
> 
> 
> Review URL: https://chromiumcodereview.appspot.com/11781003

TBR=alexeypa@chromium.org
Review URL: https://codereview.chromium.org/11829026

git-svn-id: svn://svn.chromium.org/chrome/branches/1378/src@175799 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 193 insertions, 290 deletions

diff --git a/remoting/capturer/video_frame_capturer_fake.cc b/remoting/capturer/video_frame_capturer_fake.cc
index 7c25432..a27e62cf1 100644
--- a/remoting/capturer/video_frame_capturer_fake.cc
+++ b/remoting/capturer/video_frame_capturer_fake.cc
@@ -12,8 +12,8 @@ namespace remoting {
 // VideoFrameCapturerFake generates a white picture of size kWidth x kHeight
 // with a rectangle of size kBoxWidth x kBoxHeight. The rectangle moves kSpeed
 // pixels per frame along both axes, and bounces off the sides of the screen.
-static const int kWidth = VideoFrameCapturerFake::kWidth;
-static const int kHeight = VideoFrameCapturerFake::kHeight;
+static const int kWidth = 800;
+static const int kHeight = 600;
 static const int kBoxWidth = 140;
 static const int kBoxHeight = 140;
 static const int kSpeed = 20;
diff --git a/remoting/capturer/video_frame_capturer_fake.h b/remoting/capturer/video_frame_capturer_fake.h
index 0547796..c3a818b 100644
--- a/remoting/capturer/video_frame_capturer_fake.h
+++ b/remoting/capturer/video_frame_capturer_fake.h
@@ -17,10 +17,6 @@ namespace remoting {
 // See remoting/host/video_frame_capturer.h.
 class VideoFrameCapturerFake : public VideoFrameCapturer {
  public:
-  // VideoFrameCapturerFake generates a picture of size kWidth x kHeight.
-  static const int kWidth = 800;
-  static const int kHeight = 600;
-
   VideoFrameCapturerFake();
   virtual ~VideoFrameCapturerFake();
 
diff --git a/remoting/host/chromoting_host_unittest.cc b/remoting/host/chromoting_host_unittest.cc
index 0235512..6e7c326 100644
--- a/remoting/host/chromoting_host_unittest.cc
+++ b/remoting/host/chromoting_host_unittest.cc
@@ -244,6 +244,8 @@ class ChromotingHostTest : public testing::Test {
         desktop_environment_factory_.get(),
         base::TimeDelta());
     connection_ptr->set_host_stub(client);
+    connection_ptr->set_input_stub(
+        client->desktop_environment()->event_executor());
 
     ui_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ChromotingHostTest::AddClientToHost,
diff --git a/remoting/host/client_session.cc b/remoting/host/client_session.cc
index 58320c9..f172259 100644
--- a/remoting/host/client_session.cc
+++ b/remoting/host/client_session.cc
@@ -41,10 +41,13 @@ ClientSession::ClientSession(
       connection_factory_(connection_.get()),
       desktop_environment_(desktop_environment_factory->Create()),
       client_jid_(connection_->session()->jid()),
-      input_tracker_(&host_input_filter_),
+      host_clipboard_stub_(desktop_environment_->event_executor()),
+      host_input_stub_(desktop_environment_->event_executor()),
+      input_tracker_(host_input_stub_),
       remote_input_filter_(&input_tracker_),
-      mouse_clamping_filter_(&remote_input_filter_, connection_->video_stub()),
-      disable_input_filter_(mouse_clamping_filter_.input_filter()),
+      mouse_clamping_filter_(desktop_environment_->video_capturer(),
+                             &remote_input_filter_),
+      disable_input_filter_(&mouse_clamping_filter_),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       auth_input_filter_(&disable_input_filter_),
       auth_clipboard_filter_(&disable_clipboard_filter_),
@@ -63,6 +66,7 @@ ClientSession::ClientSession(
   connection_->set_clipboard_stub(&auth_clipboard_filter_);
   connection_->set_host_stub(this);
   connection_->set_input_stub(&auth_input_filter_);
+  clipboard_echo_filter_.set_host_stub(host_clipboard_stub_);
 
   // |auth_*_filter_|'s states reflect whether the session is authenticated.
   auth_input_filter_.set_enabled(false);
@@ -123,11 +127,6 @@ void ClientSession::OnConnectionChannelsConnected(
     protocol::ConnectionToClient* connection) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(connection_.get(), connection);
-
-  // Connect the host clipboard and input stubs.
-  host_input_filter_.set_input_stub(desktop_environment_->event_executor());
-  clipboard_echo_filter_.set_host_stub(desktop_environment_->event_executor());
-
   SetDisableInputs(false);
 
   // Let the desktop environment notify us of local clipboard changes.
@@ -149,7 +148,7 @@ void ClientSession::OnConnectionChannelsConnected(
       desktop_environment_->video_capturer(),
       video_encoder.Pass(),
       connection_->client_stub(),
-      &mouse_clamping_filter_);
+      connection_->video_stub());
   ++active_recorders_;
 
   // Create an AudioScheduler if audio is enabled, to pump audio samples.
diff --git a/remoting/host/client_session.h b/remoting/host/client_session.h
index f61cb53..c4e0657 100644
--- a/remoting/host/client_session.h
+++ b/remoting/host/client_session.h
@@ -133,6 +133,10 @@ class ClientSession
     return connection_.get();
   }
 
+  DesktopEnvironment* desktop_environment() const {
+    return desktop_environment_.get();
+  }
+
   const std::string& client_jid() { return client_jid_; }
 
   bool is_authenticated() { return auth_input_filter_.enabled();  }
@@ -177,8 +181,11 @@ class ClientSession
 
   std::string client_jid_;
 
-  // Filter used as the final element in the input pipeline.
-  protocol::InputFilter host_input_filter_;
+  // The host clipboard and input stubs to which this object delegates.
+  // These are the final elements in the clipboard & input pipelines, which
+  // appear in order below.
+  protocol::ClipboardStub* host_clipboard_stub_;
+  protocol::InputStub* host_input_stub_;
 
   // Tracker used to release pressed keys and buttons when disconnecting.
   protocol::InputEventTracker input_tracker_;
@@ -190,8 +197,7 @@ class ClientSession
   MouseClampingFilter mouse_clamping_filter_;
 
   // Filter to used to stop clipboard items sent from the client being echoed
-  // back to it.  It is the final element in the clipboard (client -> host)
-  // pipeline.
+  // back to it.
   protocol::ClipboardEchoFilter clipboard_echo_filter_;
 
   // Filters used to manage enabling & disabling of input & clipboard.
diff --git a/remoting/host/client_session_unittest.cc b/remoting/host/client_session_unittest.cc
index 285bf4a..050304c 100644
--- a/remoting/host/client_session_unittest.cc
+++ b/remoting/host/client_session_unittest.cc
@@ -6,7 +6,6 @@
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/capturer/video_capturer_mock_objects.h"
-#include "remoting/capturer/video_frame_capturer_fake.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_environment.h"
@@ -27,68 +26,111 @@ using protocol::SessionConfig;
 using testing::_;
 using testing::AnyNumber;
 using testing::DeleteArg;
-using testing::DoAll;
 using testing::Expectation;
 using testing::InSequence;
 using testing::Return;
 using testing::ReturnRef;
 
-namespace {
-
-ACTION_P2(InjectClipboardEvent, connection, event) {
-  connection->clipboard_stub()->InjectClipboardEvent(event);
-}
-
-ACTION_P2(InjectKeyEvent, connection, event) {
-  connection->input_stub()->InjectKeyEvent(event);
-}
-
-ACTION_P2(InjectMouseEvent, connection, event) {
-  connection->input_stub()->InjectMouseEvent(event);
-}
-
-ACTION_P2(LocalMouseMoved, client_session, event) {
-  client_session->LocalMouseMoved(SkIPoint::Make(event.x(), event.y()));
-}
-
-}  // namespace
-
 class ClientSessionTest : public testing::Test {
  public:
-  ClientSessionTest()
-      : client_jid_("user@domain/rest-of-jid"),
-        event_executor_(NULL) {}
+  ClientSessionTest() : event_executor_(NULL) {}
+
+  virtual void SetUp() OVERRIDE {
+    ui_task_runner_ = new AutoThreadTaskRunner(
+        message_loop_.message_loop_proxy(),
+        base::Bind(&ClientSessionTest::QuitMainMessageLoop,
+                   base::Unretained(this)));
+
+    client_jid_ = "user@domain/rest-of-jid";
+
+    desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
+    EXPECT_CALL(*desktop_environment_factory_, CreatePtr())
+        .Times(AnyNumber())
+        .WillRepeatedly(Invoke(this,
+                               &ClientSessionTest::CreateDesktopEnvironment));
+
+    // Set up a large default screen size that won't affect most tests.
+    screen_size_.set(1000, 1000);
+
+    session_config_ = SessionConfig::ForTest();
+
+    // Mock protocol::Session APIs called directly by ClientSession.
+    protocol::MockSession* session = new MockSession();
+    EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(session_config_));
+    EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
+    EXPECT_CALL(*session, SetEventHandler(_));
+
+    // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
+    // HostStub is not touched by ClientSession, so we can safely pass NULL.
+    scoped_ptr<MockConnectionToClient> connection(
+        new MockConnectionToClient(session, NULL));
+    EXPECT_CALL(*connection, session()).WillRepeatedly(Return(session));
+    EXPECT_CALL(*connection, client_stub())
+        .WillRepeatedly(Return(&client_stub_));
+    EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_));
+    EXPECT_CALL(*connection, Disconnect());
+    connection_ = connection.get();
+
+    client_session_ = new ClientSession(
+        &session_event_handler_,
+        ui_task_runner_, // Audio thread.
+        ui_task_runner_, // Capture thread.
+        ui_task_runner_, // Encode thread.
+        ui_task_runner_, // Network thread.
+        connection.PassAs<protocol::ConnectionToClient>(),
+        desktop_environment_factory_.get(),
+        base::TimeDelta());
+  }
 
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
+  virtual void TearDown() OVERRIDE {
+    // MockClientSessionEventHandler won't trigger Stop, so fake it.
+    client_session_->Stop(base::Bind(
+        &ClientSessionTest::OnClientStopped, base::Unretained(this)));
 
-  // Disconnects the client session.
-  void DisconnectClientSession();
+    // Run message loop before destroying because the session is destroyed
+    // asynchronously.
+    ui_task_runner_ = NULL;
+    message_loop_.Run();
 
-  // Asynchronously stops the client session. OnClientStopped() will be called
-  // once the client session is fully stopped.
-  void StopClientSession();
+    // Verify that the client session has been stopped.
+    EXPECT_TRUE(client_session_.get() == NULL);
+  }
 
  protected:
-  // Creates a DesktopEnvironment with a fake VideoFrameCapturer, to mock
-  // DesktopEnvironmentFactory::Create().
-  DesktopEnvironment* CreateDesktopEnvironment();
+  DesktopEnvironment* CreateDesktopEnvironment() {
+    MockVideoFrameCapturer* capturer = new MockVideoFrameCapturer();
+    EXPECT_CALL(*capturer, Start(_));
+    EXPECT_CALL(*capturer, Stop());
+    EXPECT_CALL(*capturer, InvalidateRegion(_)).Times(AnyNumber());
+    EXPECT_CALL(*capturer, CaptureFrame()).Times(AnyNumber());
+    EXPECT_CALL(*capturer, size_most_recent())
+        .WillRepeatedly(ReturnRef(screen_size_));
+
+    EXPECT_TRUE(!event_executor_);
+    event_executor_ = new MockEventExecutor();
+    return new DesktopEnvironment(scoped_ptr<AudioCapturer>(NULL),
+                                  scoped_ptr<EventExecutor>(event_executor_),
+                                  scoped_ptr<VideoFrameCapturer>(capturer));
+  }
 
-  // Notifies the client session that the client connection has been
-  // authenticated and channels have been connected. This effectively enables
-  // the input pipe line and starts video capturing.
-  void ConnectClientSession();
+  void DisconnectClientSession() {
+    client_session_->Disconnect();
+    // MockSession won't trigger OnConnectionClosed, so fake it.
+    client_session_->OnConnectionClosed(client_session_->connection(),
+                                        protocol::OK);
+  }
 
-  // Invoked when the last reference to the AutoThreadTaskRunner has been
-  // released and quits the message loop to finish the test.
-  void QuitMainMessageLoop();
+  void QuitMainMessageLoop() {
+    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
 
-  // Releases the ClientSession when it has been fully stopped, allowing
-  // the MessageLoop to quit.
-  void OnClientStopped();
+  void OnClientStopped() {
+    client_session_ = NULL;
+  }
 
   // Message loop passed to |client_session_| to perform all functions on.
   MessageLoop message_loop_;
+  scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
 
   // ClientSession instance under test.
   scoped_refptr<ClientSession> client_session_;
@@ -96,9 +138,12 @@ class ClientSessionTest : public testing::Test {
   // ClientSession::EventHandler mock for use in tests.
   MockClientSessionEventHandler session_event_handler_;
 
+  // Screen size that the fake VideoFrameCapturer should report.
+  SkISize screen_size_;
+
   // Storage for values to be returned by the protocol::Session mock.
   SessionConfig session_config_;
-  const std::string client_jid_;
+  std::string client_jid_;
 
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
@@ -114,90 +159,6 @@ class ClientSessionTest : public testing::Test {
   scoped_ptr<MockDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
-void ClientSessionTest::SetUp() {
-  // Arrange to run |message_loop_| until no components depend on it.
-  scoped_refptr<AutoThreadTaskRunner> ui_task_runner = new AutoThreadTaskRunner(
-      message_loop_.message_loop_proxy(),
-      base::Bind(&ClientSessionTest::QuitMainMessageLoop,
-                 base::Unretained(this)));
-
-  desktop_environment_factory_.reset(new MockDesktopEnvironmentFactory());
-  EXPECT_CALL(*desktop_environment_factory_, CreatePtr())
-      .Times(AnyNumber())
-      .WillRepeatedly(Invoke(this,
-                             &ClientSessionTest::CreateDesktopEnvironment));
-
-  session_config_ = SessionConfig::ForTest();
-
-  // Mock protocol::Session APIs called directly by ClientSession.
-  protocol::MockSession* session = new MockSession();
-  EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(session_config_));
-  EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
-  EXPECT_CALL(*session, SetEventHandler(_));
-
-  // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
-  // HostStub is not touched by ClientSession, so we can safely pass NULL.
-  scoped_ptr<MockConnectionToClient> connection(
-      new MockConnectionToClient(session, NULL));
-  EXPECT_CALL(*connection, session()).WillRepeatedly(Return(session));
-  EXPECT_CALL(*connection, client_stub())
-      .WillRepeatedly(Return(&client_stub_));
-  EXPECT_CALL(*connection, video_stub()).WillRepeatedly(Return(&video_stub_));
-  EXPECT_CALL(*connection, Disconnect());
-  connection_ = connection.get();
-
-  client_session_ = new ClientSession(
-      &session_event_handler_,
-      ui_task_runner, // Audio thread.
-      ui_task_runner, // Capture thread.
-      ui_task_runner, // Encode thread.
-      ui_task_runner, // Network thread.
-      connection.PassAs<protocol::ConnectionToClient>(),
-      desktop_environment_factory_.get(),
-      base::TimeDelta());
-}
-
-void ClientSessionTest::TearDown() {
-  // Verify that the client session has been stopped.
-  EXPECT_TRUE(client_session_.get() == NULL);
-}
-
-void ClientSessionTest::DisconnectClientSession() {
-  client_session_->Disconnect();
-  // MockSession won't trigger OnConnectionClosed, so fake it.
-  client_session_->OnConnectionClosed(client_session_->connection(),
-                                      protocol::OK);
-}
-
-void ClientSessionTest::StopClientSession() {
-  // MockClientSessionEventHandler won't trigger Stop, so fake it.
-  client_session_->Stop(base::Bind(
-      &ClientSessionTest::OnClientStopped, base::Unretained(this)));
-}
-
-DesktopEnvironment* ClientSessionTest::CreateDesktopEnvironment() {
-  scoped_ptr<VideoFrameCapturer> video_capturer(new VideoFrameCapturerFake());
-
-  EXPECT_TRUE(!event_executor_);
-  event_executor_ = new MockEventExecutor();
-  return new DesktopEnvironment(scoped_ptr<AudioCapturer>(NULL),
-                                scoped_ptr<EventExecutor>(event_executor_),
-                                video_capturer.Pass());
-}
-
-void ClientSessionTest::ConnectClientSession() {
-  client_session_->OnConnectionAuthenticated(client_session_->connection());
-  client_session_->OnConnectionChannelsConnected(client_session_->connection());
-}
-
-void ClientSessionTest::QuitMainMessageLoop() {
-  message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
-}
-
-void ClientSessionTest::OnClientStopped() {
-  client_session_ = NULL;
-}
-
 MATCHER_P2(EqualsClipboardEvent, m, d, "") {
   return (strcmp(arg.mime_type().c_str(), m) == 0 &&
       memcmp(arg.data().data(), d, arg.data().size()) == 0);
@@ -220,19 +181,6 @@ TEST_F(ClientSessionTest, ClipboardStubFilter) {
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(*event_executor_, StartPtr(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
-
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .WillOnce(DoAll(
-          // This event should get through to the clipboard stub.
-          InjectClipboardEvent(connection_, clipboard_event2),
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          // This event should not get through to the clipboard stub,
-          // because the client has disconnected.
-          InjectClipboardEvent(connection_, clipboard_event3),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
   EXPECT_CALL(*event_executor_, InjectClipboardEvent(EqualsClipboardEvent(
       kMimeTypeTextUtf8, "b")));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
@@ -240,9 +188,14 @@ TEST_F(ClientSessionTest, ClipboardStubFilter) {
   // This event should not get through to the clipboard stub,
   // because the client isn't authenticated yet.
   connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event1);
-
-  ConnectClientSession();
-  message_loop_.Run();
+  client_session_->OnConnectionAuthenticated(client_session_->connection());
+  client_session_->OnConnectionChannelsConnected(client_session_->connection());
+  // This event should get through to the clipboard stub.
+  connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event2);
+  DisconnectClientSession();
+  // This event should not get through to the clipboard stub,
+  // because the client has disconnected.
+  connection_->clipboard_stub()->InjectClipboardEvent(clipboard_event3);
 }
 
 MATCHER_P2(EqualsUsbEvent, usb_keycode, pressed, "") {
@@ -291,22 +244,6 @@ TEST_F(ClientSessionTest, InputStubFilter) {
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(*event_executor_, StartPtr(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
-
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .WillOnce(DoAll(
-          // These events should get through to the input stub.
-          InjectKeyEvent(connection_, key_event2_down),
-          InjectKeyEvent(connection_, key_event2_up),
-          InjectMouseEvent(connection_, mouse_event2),
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          // These events should not get through to the input stub,
-          // because the client has disconnected.
-          InjectKeyEvent(connection_, key_event3),
-          InjectMouseEvent(connection_, mouse_event3),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
   EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, true)));
   EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, false)));
   EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(200, 201)));
@@ -316,9 +253,17 @@ TEST_F(ClientSessionTest, InputStubFilter) {
   // because the client isn't authenticated yet.
   connection_->input_stub()->InjectKeyEvent(key_event1);
   connection_->input_stub()->InjectMouseEvent(mouse_event1);
-
-  ConnectClientSession();
-  message_loop_.Run();
+  client_session_->OnConnectionAuthenticated(client_session_->connection());
+  client_session_->OnConnectionChannelsConnected(client_session_->connection());
+  // These events should get through to the input stub.
+  connection_->input_stub()->InjectKeyEvent(key_event2_down);
+  connection_->input_stub()->InjectKeyEvent(key_event2_up);
+  connection_->input_stub()->InjectMouseEvent(mouse_event2);
+  DisconnectClientSession();
+  // These events should not get through to the input stub,
+  // because the client has disconnected.
+  connection_->input_stub()->InjectKeyEvent(key_event3);
+  connection_->input_stub()->InjectMouseEvent(mouse_event3);
 }
 
 TEST_F(ClientSessionTest, LocalInputTest) {
@@ -336,30 +281,25 @@ TEST_F(ClientSessionTest, LocalInputTest) {
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(*event_executor_, StartPtr(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
-
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .WillOnce(DoAll(
-          // This event should get through to the input stub.
-          InjectMouseEvent(connection_, mouse_event1),
-          // This one should too because the local event echoes the remote one.
-          LocalMouseMoved(client_session_.get(), mouse_event1),
-          InjectMouseEvent(connection_, mouse_event2),
-          // This one should not.
-          LocalMouseMoved(client_session_.get(), mouse_event1),
-          InjectMouseEvent(connection_, mouse_event3),
-          // TODO(jamiewalch): Verify that remote inputs are re-enabled
-          // eventually (via dependency injection, not sleep!)
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
   EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(100, 101)));
   EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(200, 201)));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
-  ConnectClientSession();
-  message_loop_.Run();
+  client_session_->OnConnectionAuthenticated(client_session_->connection());
+  client_session_->OnConnectionChannelsConnected(client_session_->connection());
+  // This event should get through to the input stub.
+  connection_->input_stub()->InjectMouseEvent(mouse_event1);
+  // This one should too because the local event echoes the remote one.
+  client_session_->LocalMouseMoved(SkIPoint::Make(mouse_event1.x(),
+                                                  mouse_event1.y()));
+  connection_->input_stub()->InjectMouseEvent(mouse_event2);
+  // This one should not.
+  client_session_->LocalMouseMoved(SkIPoint::Make(mouse_event1.x(),
+                                                  mouse_event1.y()));
+  connection_->input_stub()->InjectMouseEvent(mouse_event3);
+  // TODO(jamiewalch): Verify that remote inputs are re-enabled eventually
+  // (via dependency injection, not sleep!)
+  DisconnectClientSession();
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
@@ -379,17 +319,6 @@ TEST_F(ClientSessionTest, RestoreEventState) {
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(*event_executor_, StartPtr(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
-
-  // Wait for the first video packet to be captured to make sure that
-  // the injected input will go though. Otherwise mouse events will be blocked
-  // by the mouse clamping filter.
-  EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-      .WillOnce(DoAll(
-          InjectKeyEvent(connection_, key1),
-          InjectKeyEvent(connection_, key2),
-          InjectMouseEvent(connection_, mousedown),
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
   EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(1, true)));
   EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, true)));
   EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseButtonEvent(
@@ -400,62 +329,48 @@ TEST_F(ClientSessionTest, RestoreEventState) {
       protocol::MouseEvent::BUTTON_LEFT, false)));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
-  ConnectClientSession();
-  message_loop_.Run();
+  client_session_->OnConnectionAuthenticated(client_session_->connection());
+  client_session_->OnConnectionChannelsConnected(client_session_->connection());
+
+  connection_->input_stub()->InjectKeyEvent(key1);
+  connection_->input_stub()->InjectKeyEvent(key2);
+  connection_->input_stub()->InjectMouseEvent(mousedown);
+
+  DisconnectClientSession();
 }
 
 TEST_F(ClientSessionTest, ClampMouseEvents) {
+  screen_size_.set(200, 100);
+
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(*event_executor_, StartPtr(_));
   Expectation connected =
       EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
   EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
 
+  client_session_->OnConnectionAuthenticated(client_session_->connection());
+  client_session_->OnConnectionChannelsConnected(client_session_->connection());
+
   int input_x[3] = { -999, 100, 999 };
-  int expected_x[3] = { 0, 100, VideoFrameCapturerFake::kWidth - 1 };
+  int expected_x[3] = { 0, 100, 199 };
   int input_y[3] = { -999, 50, 999 };
-  int expected_y[3] = { 0, 50, VideoFrameCapturerFake::kHeight - 1 };
-
-  // Inject the 1st event once a video packet has been received.
-  protocol::MouseEvent injected_event;
-  injected_event.set_x(input_x[0]);
-  injected_event.set_y(input_y[0]);
-  connected =
-      EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
-          .After(connected)
-          .WillOnce(InjectMouseEvent(connection_, injected_event));
-
-  protocol::MouseEvent expected_event;
+  int expected_y[3] = { 0, 50, 99 };
+
+  protocol::MouseEvent event;
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 3; i++) {
-      // Skip the first iteration since the 1st event has been injected already.
-      if (i > 0 || j > 0) {
-        injected_event.set_x(input_x[i]);
-        injected_event.set_y(input_y[j]);
-        connected =
-            EXPECT_CALL(*event_executor_,
-                        InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
-                                                          expected_event.y())))
-                .After(connected)
-                .WillOnce(InjectMouseEvent(connection_, injected_event));
-      }
-
-      expected_event.set_x(expected_x[i]);
-      expected_event.set_y(expected_y[j]);
+      event.set_x(input_x[i]);
+      event.set_y(input_y[j]);
+      connected =
+          EXPECT_CALL(*event_executor_,
+                      InjectMouseEvent(EqualsMouseEvent(expected_x[i],
+                                                        expected_y[j])))
+              .After(connected);
+      connection_->input_stub()->InjectMouseEvent(event);
     }
   }
 
-  // Shutdown the connection once the last event has been received.
-  EXPECT_CALL(*event_executor_,
-              InjectMouseEvent(EqualsMouseEvent(expected_event.x(),
-                                                expected_event.y())))
-      .After(connected)
-      .WillOnce(DoAll(
-          InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
-          InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
-
-  ConnectClientSession();
-  message_loop_.Run();
+  DisconnectClientSession();
 }
 
 }  // namespace remoting
diff --git a/remoting/host/mouse_clamping_filter.cc b/remoting/host/mouse_clamping_filter.cc
index 3fdecbd..04ee46c 100644
--- a/remoting/host/mouse_clamping_filter.cc
+++ b/remoting/host/mouse_clamping_filter.cc
@@ -4,34 +4,24 @@
 
 #include "remoting/host/mouse_clamping_filter.h"
 
+#include "remoting/capturer/video_frame_capturer.h"
 #include "remoting/proto/event.pb.h"
-#include "remoting/proto/video.pb.h"
 
 namespace remoting {
 
-MouseClampingFilter::MouseClampingFilter(
-    protocol::InputStub* input_stub,
-    protocol::VideoStub* video_stub)
-    : input_filter_(input_stub),
-      video_stub_(video_stub) {
+MouseClampingFilter::MouseClampingFilter(VideoFrameCapturer* capturer,
+                                         protocol::InputStub* input_stub)
+  : MouseInputFilter(input_stub), capturer_(capturer) {
 }
 
 MouseClampingFilter::~MouseClampingFilter() {
 }
 
-void MouseClampingFilter::ProcessVideoPacket(
-    scoped_ptr<VideoPacket> video_packet,
-    const base::Closure& done) {
-  // Configure the MouseInputFilter to clamp to the video dimensions.
-  if (video_packet->format().has_screen_width() &&
-      video_packet->format().has_screen_height()) {
-    SkISize screen_size = SkISize::Make(video_packet->format().screen_width(),
-                                        video_packet->format().screen_height());
-    input_filter_.set_input_size(screen_size);
-    input_filter_.set_output_size(screen_size);
-  }
-
-  video_stub_->ProcessVideoPacket(video_packet.Pass(), done);
+void MouseClampingFilter::InjectMouseEvent(const protocol::MouseEvent& event) {
+  // Ensure that the MouseInputFilter is clamping to the current dimensions.
+  set_output_size(capturer_->size_most_recent());
+  set_input_size(capturer_->size_most_recent());
+  MouseInputFilter::InjectMouseEvent(event);
 }
 
 }  // namespace remoting
diff --git a/remoting/host/mouse_clamping_filter.h b/remoting/host/mouse_clamping_filter.h
index 9d8503cb..02ff17a 100644
--- a/remoting/host/mouse_clamping_filter.h
+++ b/remoting/host/mouse_clamping_filter.h
@@ -7,30 +7,25 @@
 
 #include "base/compiler_specific.h"
 #include "remoting/protocol/mouse_input_filter.h"
-#include "remoting/protocol/video_stub.h"
 
 namespace remoting {
 
-// Filtering VideoStub implementation which configures a MouseInputFilter to
-// clamp mouse events to fall within the dimensions of the most-recently
-// received video frame.
-class MouseClampingFilter : public protocol::VideoStub {
+class VideoFrameCapturer;
+
+// Filtering InputStub implementation which clamps mouse each mouse event to
+// the current dimensions of a VideoFrameCapturer instance before passing
+// them on to the target |input_stub|.
+class MouseClampingFilter : public protocol::MouseInputFilter {
  public:
-  MouseClampingFilter(protocol::InputStub* input_stub,
-                      protocol::VideoStub* video_stub);
+  MouseClampingFilter(VideoFrameCapturer* capturer,
+                      protocol::InputStub* input_stub);
   virtual ~MouseClampingFilter();
 
-  protocol::InputStub* input_filter() { return &input_filter_; }
-
-  // protocol::VideoStub implementation.
-  virtual void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
-                                  const base::Closure& done) OVERRIDE;
+  // InputStub overrides.
+  virtual void InjectMouseEvent(const protocol::MouseEvent& event) OVERRIDE;
 
  private:
-  // Clamps mouse event coordinates to the video dimensions.
-  protocol::MouseInputFilter input_filter_;
-
-  protocol::VideoStub* video_stub_;
+  VideoFrameCapturer* capturer_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseClampingFilter);
 };