Create a desktop environment instance late so that it will see the curtain_required flag.

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 "media/video/capture/screen/screen_capturer_fake.h"
 #include "media/video/capture/screen/screen_capturer_mock_objects.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 11 matching lines @@
 using protocol::MockInputStub;
 using protocol::MockSession;
 using protocol::MockVideoStub;
 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;
+using testing::Sequence;
 
 namespace {
 
 ACTION_P2(InjectClipboardEvent, connection, event) {
   connection->clipboard_stub()->InjectClipboardEvent(event);
 }
 
 ACTION_P2(InjectKeyEvent, connection, event) {
   connection->input_stub()->InjectKeyEvent(event);
 }
@@ skipping 197 matching lines @@
   clipboard_event1.set_data("a");
 
   protocol::ClipboardEvent clipboard_event2;
   clipboard_event2.set_mime_type(kMimeTypeTextUtf8);
   clipboard_event2.set_data("b");
 
   protocol::ClipboardEvent clipboard_event3;
   clipboard_event3.set_mime_type(kMimeTypeTextUtf8);
   clipboard_event3.set_data("c");
 
-  InSequence s;
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
-  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
+  Expectation authenticated =
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
+      .After(authenticated);
 
   // 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.
+  Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+      .InSequence(s)
+      .After(authenticated)
       .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(_));
+      kMimeTypeTextUtf8, "b")))
+      .InSequence(s);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
+      .InSequence(s);
 
   // 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();
 }
 
 MATCHER_P2(EqualsUsbEvent, usb_keycode, pressed, "") {
@@ skipping 31 matching lines @@
   mouse_event1.set_y(101);
 
   protocol::MouseEvent mouse_event2;
   mouse_event2.set_x(200);
   mouse_event2.set_y(201);
 
   protocol::MouseEvent mouse_event3;
   mouse_event3.set_x(300);
   mouse_event3.set_y(301);
 
-  InSequence s;
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
-  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
+  Expectation authenticated =
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
+      .After(authenticated);
 
   // 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.
+  Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+      .InSequence(s)
+      .After(authenticated)
       .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)));
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
+  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, true)))
+      .InSequence(s);
+  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, false)))
+      .InSequence(s);
+  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
+      .InSequence(s);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
+      .InSequence(s);
 
   // These events should not get through to the input stub,
   // because the client isn't authenticated yet.
   connection_->input_stub()->InjectKeyEvent(key_event1);
   connection_->input_stub()->InjectMouseEvent(mouse_event1);
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ClientSessionTest, LocalInputTest) {
   protocol::MouseEvent mouse_event1;
   mouse_event1.set_x(100);
   mouse_event1.set_y(101);
   protocol::MouseEvent mouse_event2;
   mouse_event2.set_x(200);
   mouse_event2.set_y(201);
   protocol::MouseEvent mouse_event3;
   mouse_event3.set_x(300);
   mouse_event3.set_y(301);
 
-  InSequence s;
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
-  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
+  Expectation authenticated =
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
+      .After(authenticated);
 
   // 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.
+  Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+      .InSequence(s)
+      .After(authenticated)
       .WillOnce(DoAll(
           // This event should get through to the input stub.
           InjectMouseEvent(connection_, mouse_event1),
 #if !defined(OS_WIN)
           // The OS echoes the injected event back.
           LocalMouseMoved(client_session_.get(), mouse_event1),
 #endif  // !defined(OS_WIN)
           // This one should get throught as well.
           InjectMouseEvent(connection_, mouse_event2),
           // Now this is a genuine local event.
           LocalMouseMoved(client_session_.get(), mouse_event1),
           // This one should be blocked because of the previous  local input
           // event.
           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(_));
+  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(100, 101)))
+      .InSequence(s);
+  EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseEvent(200, 201)))
+      .InSequence(s);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
+      .InSequence(s);
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ClientSessionTest, RestoreEventState) {
   protocol::KeyEvent key1;
   key1.set_pressed(true);
   key1.set_usb_keycode(1);
 
   protocol::KeyEvent key2;
   key2.set_pressed(true);
   key2.set_usb_keycode(2);
 
   protocol::MouseEvent mousedown;
   mousedown.set_button(protocol::MouseEvent::BUTTON_LEFT);
   mousedown.set_button_down(true);
 
-  InSequence s;
-  EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
-  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
+  Expectation authenticated =
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
+      .After(authenticated);
 
   // 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.
+  Sequence s;
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
+      .InSequence(s)
+      .After(authenticated)
       .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_, InjectKeyEvent(EqualsUsbEvent(1, true)))
+      .InSequence(s);
+  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, true)))
+      .InSequence(s);
   EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseButtonEvent(
-      protocol::MouseEvent::BUTTON_LEFT, true)));
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(1, false)));
-  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, false)));
+      protocol::MouseEvent::BUTTON_LEFT, true)))
+      .InSequence(s);
+  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(1, false)))
+      .InSequence(s);
+  EXPECT_CALL(*event_executor_, InjectKeyEvent(EqualsUsbEvent(2, false)))
+      .InSequence(s);
   EXPECT_CALL(*event_executor_, InjectMouseEvent(EqualsMouseButtonEvent(
-      protocol::MouseEvent::BUTTON_LEFT, false)));
-  EXPECT_CALL(session_event_handler_, OnSessionClosed(_));
+      protocol::MouseEvent::BUTTON_LEFT, false)))
+      .InSequence(s);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
+      .InSequence(s);
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 TEST_F(ClientSessionTest, ClampMouseEvents) {
-  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(_));
+  Expectation authenticated =
+      EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_))
+      .After(authenticated);
+  EXPECT_CALL(session_event_handler_, OnSessionClosed(_))
+      .After(authenticated);
+
+  Expectation connected = authenticated;
 
   int input_x[3] = { -999, 100, 999 };
   int expected_x[3] = { 0, 100, media::ScreenCapturerFake::kWidth - 1 };
   int input_y[3] = { -999, 50, 999 };
   int expected_y[3] = { 0, 50, media::ScreenCapturerFake::kHeight - 1 };
 
   protocol::MouseEvent expected_event;
   for (int j = 0; j < 3; j++) {
     for (int i = 0; i < 3; i++) {
       protocol::MouseEvent injected_event;
@@ skipping 29 matching lines @@
       .After(connected)
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 }  // namespace remoting