[remoting_unittests] Moving the variable used to mock VideoFrameCapturer::size_most_recent() to the…

remoting/host/client_session_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 "base/message_loop.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_environment.h"
@@ skipping 50 matching lines @@
     EXPECT_CALL(*capturer_, Stop());
     EXPECT_CALL(*capturer_, InvalidateRegion(_)).Times(AnyNumber());
     EXPECT_CALL(*capturer_, CaptureInvalidRegion(_)).Times(AnyNumber());
 
     scoped_ptr<DesktopEnvironment> desktop_environment(new DesktopEnvironment(
         scoped_ptr<AudioCapturer>(NULL),
         scoped_ptr<EventExecutor>(event_executor_),
         scoped_ptr<VideoFrameCapturer>(capturer_)));
 
     // Set up a large default screen size that won't affect most tests.
-    default_screen_size_.set(1000, 1000);
+    screen_size_.set(1000, 1000);
     EXPECT_CALL(*capturer_, size_most_recent())
-        .WillRepeatedly(ReturnRef(default_screen_size_));
+        .WillRepeatedly(ReturnRef(screen_size_));
 
     session_config_ = SessionConfig::GetDefault();
 
     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(_));
     EXPECT_CALL(*session, Close());
     scoped_ptr<protocol::ConnectionToClient> connection(
         new protocol::ConnectionToClient(session));
@@ skipping 35 matching lines @@
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   void OnClientStopped() {
     client_session_ = NULL;
   }
 
   MessageLoop message_loop_;
   scoped_refptr<AutoThreadTaskRunner> ui_task_runner_;
   MockChromotingHostContext context_;
-  SkISize default_screen_size_;
+  SkISize screen_size_;
   std::string client_jid_;
   MockHostStub host_stub_;
   MockEventExecutor* event_executor_;
   MockVideoFrameCapturer* capturer_;
   MockClientSessionEventHandler session_event_handler_;
   scoped_refptr<ClientSession> client_session_;
   SessionConfig session_config_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   protocol::ConnectionToClient* connection_;
@@ skipping 177 matching lines @@
   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) {
-  SkISize screen(SkISize::Make(200, 100));
-  EXPECT_CALL(*capturer_, size_most_recent())
-      .WillRepeatedly(ReturnRef(screen));
+  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(_));
   EXPECT_CALL(*event_executor_, StopAndDeleteMock());
 
   client_session_->OnConnectionAuthenticated(client_session_->connection());
   client_session_->OnConnectionChannelsConnected(client_session_->connection());
@@ skipping 14 matching lines @@
                                                         expected_y[j])))
               .After(connected);
       connection_->input_stub()->InjectMouseEvent(event);
     }
   }
 
   DisconnectClientSession();
 }
 
 }  // namespace remoting