Revert 176126 - the reverted change depends on another CL, so reverting it...

Revert 176126 - the reverted change depends on another CL, so reverting it breaks the build. Undoing the revert.

> Revert 175648 because it causes http://crbug.com/169126.
> 
> > 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
> BUG=104544,169126
> Review URL: https://codereview.chromium.org/11817048

TBR=alexeypa@google.com

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@176130 0039d316-1c4b-4281-b951-d872f2087c98

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 = 800;
-static const int kHeight = 600;
+static const int kWidth = VideoFrameCapturerFake::kWidth;
+static const int kHeight = VideoFrameCapturerFake::kHeight;
 static const int kBoxWidth = 140;
 static const int kBoxHeight = 140;
 static const int kSpeed = 20;

remoting/capturer/video_frame_capturer_fake.h

@@ -17,6 +17,10 @@ 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();
 

remoting/host/chromoting_host_unittest.cc

@@ -244,8 +244,6 @@ 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,

remoting/host/client_session.cc

@@ -41,13 +41,10 @@ ClientSession::ClientSession(
       connection_factory_(connection_.get()),
       desktop_environment_(desktop_environment_factory->Create()),
       client_jid_(connection_->session()->jid()),
-      host_clipboard_stub_(desktop_environment_->event_executor()),
-      host_input_stub_(desktop_environment_->event_executor()),
-      input_tracker_(host_input_stub_),
+      input_tracker_(&host_input_filter_),
       remote_input_filter_(&input_tracker_),
-      mouse_clamping_filter_(desktop_environment_->video_capturer(),
-                             &remote_input_filter_),
-      disable_input_filter_(&mouse_clamping_filter_),
+      mouse_clamping_filter_(&remote_input_filter_, connection_->video_stub()),
+      disable_input_filter_(mouse_clamping_filter_.input_filter()),
       disable_clipboard_filter_(clipboard_echo_filter_.host_filter()),
       auth_input_filter_(&disable_input_filter_),
       auth_clipboard_filter_(&disable_clipboard_filter_),
@@ -66,7 +63,6 @@ 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);
@@ -127,6 +123,11 @@ 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.
@@ -148,7 +149,7 @@ void ClientSession::OnConnectionChannelsConnected(
       desktop_environment_->video_capturer(),
       video_encoder.Pass(),
       connection_->client_stub(),
-      connection_->video_stub());
+      &mouse_clamping_filter_);
   ++active_recorders_;
 
   // Create an AudioScheduler if audio is enabled, to pump audio samples.

remoting/host/client_session.h

@@ -133,10 +133,6 @@ 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();  }
@@ -181,11 +177,8 @@ class ClientSession
 
   std::string client_jid_;
 
-  // 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_;
+  // Filter used as the final element in the input pipeline.
+  protocol::InputFilter host_input_filter_;
 
   // Tracker used to release pressed keys and buttons when disconnecting.
   protocol::InputEventTracker input_tracker_;
@@ -197,7 +190,8 @@ class ClientSession
   MouseClampingFilter mouse_clamping_filter_;
 
   // Filter to used to stop clipboard items sent from the client being echoed
-  // back to it.
+  // back to it.  It is the final element in the clipboard (client -> host)
+  // pipeline.
   protocol::ClipboardEchoFilter clipboard_echo_filter_;
 
   // Filters used to manage enabling & disabling of input & clipboard.

remoting/host/mouse_clamping_filter.cc

@@ -4,24 +4,34 @@
 
 #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(VideoFrameCapturer* capturer,
-                                         protocol::InputStub* input_stub)
-  : MouseInputFilter(input_stub), capturer_(capturer) {
+MouseClampingFilter::MouseClampingFilter(
+    protocol::InputStub* input_stub,
+    protocol::VideoStub* video_stub)
+    : input_filter_(input_stub),
+      video_stub_(video_stub) {
 }
 
 MouseClampingFilter::~MouseClampingFilter() {
 }
 
-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);
+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);
 }
 
 }  // namespace remoting

remoting/host/mouse_clamping_filter.h

@@ -7,25 +7,30 @@
 
 #include "base/compiler_specific.h"
 #include "remoting/protocol/mouse_input_filter.h"
+#include "remoting/protocol/video_stub.h"
 
 namespace remoting {
 
-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 {
+// 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 {
  public:
-  MouseClampingFilter(VideoFrameCapturer* capturer,
-                      protocol::InputStub* input_stub);
+  MouseClampingFilter(protocol::InputStub* input_stub,
+                      protocol::VideoStub* video_stub);
   virtual ~MouseClampingFilter();
 
-  // InputStub overrides.
-  virtual void InjectMouseEvent(const protocol::MouseEvent& event) OVERRIDE;
+  protocol::InputStub* input_filter() { return &input_filter_; }
+
+  // protocol::VideoStub implementation.
+  virtual void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
+                                  const base::Closure& done) OVERRIDE;
 
  private:
-  VideoFrameCapturer* capturer_;
+  // Clamps mouse event coordinates to the video dimensions.
+  protocol::MouseInputFilter input_filter_;
+
+  protocol::VideoStub* video_stub_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseClampingFilter);
 };