Fixed a typo in DesktopSessionProxy::SetScreenResolution().

remoting/host/ipc_desktop_environment_unittest.cc

 // Copyright (c) 2013 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 41 matching lines @@
 class FakeDaemonSender : public IPC::Sender {
  public:
   FakeDaemonSender() {}
   virtual ~FakeDaemonSender() {}
 
   // IPC::Sender implementation.
   virtual bool Send(IPC::Message* message) OVERRIDE;
 
   MOCK_METHOD3(ConnectTerminal, void(int, const ScreenResolution&, bool));
   MOCK_METHOD1(DisconnectTerminal, void(int));
+  MOCK_METHOD2(SetScreenResolution, void(int, const ScreenResolution&));
 
  private:
   void OnMessageReceived(const IPC::Message& message);
 
   DISALLOW_COPY_AND_ASSIGN(FakeDaemonSender);
 };
 
 // Receives messages sent from the desktop process to the daemon.
 class MockDaemonListener : public IPC::Listener {
  public:
@@ skipping 16 matching lines @@
   return true;
 }
 
 void FakeDaemonSender::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(FakeDaemonSender, message)
     IPC_MESSAGE_HANDLER(ChromotingNetworkHostMsg_ConnectTerminal,
                         ConnectTerminal)
     IPC_MESSAGE_HANDLER(ChromotingNetworkHostMsg_DisconnectTerminal,
                         DisconnectTerminal)
+    IPC_MESSAGE_HANDLER(ChromotingNetworkDaemonMsg_SetScreenResolution,
+                        SetScreenResolution)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   EXPECT_TRUE(handled);
 }
 
 bool MockDaemonListener::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MockDaemonListener, message)
     IPC_MESSAGE_HANDLER(ChromotingDesktopDaemonMsg_DesktopAttached,
@@ skipping 76 matching lines @@
   MockDaemonListener desktop_listener_;
 
   FakeDaemonSender daemon_channel_;
 
   scoped_ptr<IpcDesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
 
   // The IPC input injector.
   scoped_ptr<InputInjector> input_injector_;
 
+  // The IPC screen controls.
+  scoped_ptr<ScreenControls> screen_controls_;
+
   // The IPC screen capturer.
   scoped_ptr<media::ScreenCapturer> video_capturer_;
 
   // Represents the desktop process running in a user session.
   scoped_ptr<DesktopProcess> desktop_process_;
 
   // Input injector owned by |desktop_process_|.
   MockInputInjector* remote_input_injector_;
 
   // The last |terminal_id| passed to ConnectTermina();
@@ skipping 65 matching lines @@
   // Create a desktop environment instance.
   desktop_environment_factory_.reset(new IpcDesktopEnvironmentFactory(
       task_runner_,
       task_runner_,
       task_runner_,
       io_task_runner_,
       &daemon_channel_));
   desktop_environment_ = desktop_environment_factory_->Create(
       client_session_control_factory_.GetWeakPtr());
 
+  screen_controls_ = desktop_environment_->CreateScreenControls();
+
   // Create the input injector.
   input_injector_ = desktop_environment_->CreateInputInjector();
 
   // Create the screen capturer.
   video_capturer_ =
       desktop_environment_->CreateVideoCapturer();
 
   desktop_environment_->SetCapabilities(std::string());
 }
 
@@ skipping 47 matching lines @@
   EXPECT_CALL(*remote_input_injector_, StartPtr(_));
   return remote_input_injector_;
 }
 
 media::ScreenCapturer* IpcDesktopEnvironmentTest::CreateVideoCapturer() {
   return new media::ScreenCapturerFake();
 }
 
 void IpcDesktopEnvironmentTest::DeleteDesktopEnvironment() {
   input_injector_.reset();
+  screen_controls_.reset();
   video_capturer_.reset();
 
   // Trigger DisconnectTerminal().
   desktop_environment_.reset();
 }
 
 void IpcDesktopEnvironmentTest::ReflectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   clipboard_stub_->InjectClipboardEvent(event);
 }
@@ skipping 255 matching lines @@
   protocol::MouseEvent event;
   event.set_x(0);
   event.set_y(0);
   input_injector_->InjectMouseEvent(event);
 
   task_runner_ = NULL;
   io_task_runner_ = NULL;
   main_run_loop_.Run();
 }
 
+// Tests that setting the desktop resolution works.
+TEST_F(IpcDesktopEnvironmentTest, SetScreenResolution) {
+  scoped_ptr<protocol::MockClipboardStub> clipboard_stub(
+      new protocol::MockClipboardStub());
+  EXPECT_CALL(*clipboard_stub, InjectClipboardEvent(_))
+      .Times(0);
+
+  // Start the input injector and screen capturer.
+  input_injector_->Start(clipboard_stub.PassAs<protocol::ClipboardStub>());
+  video_capturer_->Start(&screen_capturer_callback_);
+
+  // Run the message loop until the desktop is attached.
+  setup_run_loop_->Run();
+
+  EXPECT_CALL(daemon_channel_, SetScreenResolution(_, _))
+      .Times(1)
+      .WillOnce(InvokeWithoutArgs(
+          this, &IpcDesktopEnvironmentTest::DeleteDesktopEnvironment));
+
+  // Change the desktop resolution.
+  screen_controls_->SetScreenResolution(ScreenResolution(
+      webrtc::DesktopSize(100, 100),
+      webrtc::DesktopVector(96, 96)));
+
+  task_runner_ = NULL;
+  io_task_runner_ = NULL;
+  main_run_loop_.Run();
+}
+
 }  // namespace remoting