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;
+  Sequence s;
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .InSequence(s);
   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(_, _))
+      .InSequence(s)

[Wez, 2013/03/14 04:15:54]

Aren't you effectively saying that you expect the first ProcessVideoPacket to
occur only after the EventExecutor::StartPtr?  Is that actually guaranteed?

[alexeypa (please no reviews), 2013/03/14 19:09:06]

It is not guaranteed if we assume that video scheduler, capturer and encoder can
run on the same thread.

[Wez, 2013/03/15 00:15:26]

nit: If you instead save the OnSessionAuthenticated expectation then you can
expect that StartPtr, OnSessionChannelsConnected and ProcessVideoPacketPtr must
all come after it. You should still be able to use InSequence for the sequential
portion of the expectations, provided the first of them is
After(ProcessVideoPacketPtr).

[alexeypa (please no reviews), 2013/03/15 00:28:02]

Done.

       .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;
+  Sequence s;
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .InSequence(s);
   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(_, _))
+      .InSequence(s)

[Wez, 2013/03/14 04:15:54]

See above.

       .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;
+  Sequence s;
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .InSequence(s);
   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(_, _))
+      .InSequence(s)

[Wez, 2013/03/14 04:15:54]

See above.

       .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;
+  Sequence s;
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
-  EXPECT_CALL(*event_executor_, StartPtr(_));
+  EXPECT_CALL(*event_executor_, StartPtr(_))
+      .InSequence(s);
   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(_, _))
+      .InSequence(s)

[Wez, 2013/03/14 04:15:54]

See above.

       .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(_));
@@ skipping 40 matching lines @@
       .After(connected)
       .WillOnce(DoAll(
           InvokeWithoutArgs(this, &ClientSessionTest::DisconnectClientSession),
           InvokeWithoutArgs(this, &ClientSessionTest::StopClientSession)));
 
   ConnectClientSession();
   message_loop_.Run();
 }
 
 }  // namespace remoting