[Chromoting] Use HostExperimentSessionPlugin in host

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 "remoting/host/client_session.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/codec/video_encoder_verbatim.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/fake_desktop_environment.h"
 #include "remoting/host/fake_host_extension.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
 #include "remoting/host/host_extension.h"
 #include "remoting/host/host_extension_session.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/protocol/fake_connection_to_client.h"
 #include "remoting/protocol/fake_desktop_capturer.h"
+#include "remoting/protocol/fake_session.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/test_event_matchers.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
 
+using protocol::FakeSession;
 using protocol::MockClientStub;
 using protocol::MockHostStub;
 using protocol::MockInputStub;
-using protocol::MockSession;
 using protocol::MockVideoStub;
 using protocol::SessionConfig;
 using protocol::test::EqualsClipboardEvent;
 using protocol::test::EqualsMouseButtonEvent;
 using protocol::test::EqualsMouseMoveEvent;
 using protocol::test::EqualsKeyEvent;
 
 using testing::_;
 using testing::AtLeast;
 using testing::ReturnRef;
@@ skipping 36 matching lines @@
   protocol::ClipboardEvent result;
   result.set_mime_type(kMimeTypeTextUtf8);
   result.set_data(text);
   return result;
 }
 
 }  // namespace
 
 class ClientSessionTest : public testing::Test {
  public:
-  ClientSessionTest() : client_jid_("user@domain/rest-of-jid") {}
+  ClientSessionTest() = default;
 
   void SetUp() override;
   void TearDown() override;
 
+ protected:
+  // Creates the client session from a FakeSession instance.
+  void CreateClientSession(std::unique_ptr<protocol::FakeSession> session);
+
   // Creates the client session.
   void CreateClientSession();
 
- protected:
   // Notifies the client session that the client connection has been
   // authenticated and channels have been connected. This effectively enables
   // the input pipe line and starts video capturing.
   void ConnectClientSession();
 
   // Fakes video size notification from the VideoStream.
   void NotifyVideoSize();
 
-  // Creates expectations to send an extension message and to disconnect
-  // afterwards.
-  void SetSendMessageAndDisconnectExpectation(const std::string& message_type);
-
   // Message loop that will process all ClientSession tasks.
   base::MessageLoop message_loop_;
 
   // AutoThreadTaskRunner on which |client_session_| will be run.
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
 
   // Used to run |message_loop_| after each test, until no objects remain that
   // require it.
   base::RunLoop run_loop_;
 
   // HostExtensions to pass when creating the ClientSession. Caller retains
   // ownership of the HostExtensions themselves.
   std::vector<HostExtension*> extensions_;
 
   // ClientSession instance under test.
   std::unique_ptr<ClientSession> client_session_;
 
   // ClientSession::EventHandler mock for use in tests.
   MockClientSessionEventHandler session_event_handler_;
 
-  // Storage for values to be returned by the protocol::Session mock.
-  std::unique_ptr<SessionConfig> session_config_;
-  const std::string client_jid_;
-
   // Stubs returned to |client_session_| components by |connection_|.
   MockClientStub client_stub_;
 
   // ClientSession owns |connection_| but tests need it to inject fake events.
   protocol::FakeConnectionToClient* connection_;
 
   std::unique_ptr<FakeDesktopEnvironmentFactory> desktop_environment_factory_;
 };
 
 void ClientSessionTest::SetUp() {
   // Arrange to run |message_loop_| until no components depend on it.
   task_runner_ = new AutoThreadTaskRunner(
       message_loop_.task_runner(), run_loop_.QuitClosure());
 
   desktop_environment_factory_.reset(
       new FakeDesktopEnvironmentFactory(message_loop_.task_runner()));
-  session_config_ = SessionConfig::ForTest();
 }
 
 void ClientSessionTest::TearDown() {
   if (client_session_) {
     client_session_->DisconnectSession(protocol::OK);
     client_session_.reset();
     desktop_environment_factory_.reset();
   }
 
   // Clear out |task_runner_| reference so the loop can quit, and run it until
   // it does.
   task_runner_ = nullptr;
   run_loop_.Run();
 }
 
-void ClientSessionTest::CreateClientSession() {
-  // Mock protocol::Session APIs called directly by ClientSession.
-  std::unique_ptr<protocol::MockSession> session(new MockSession());
-  EXPECT_CALL(*session, config()).WillRepeatedly(ReturnRef(*session_config_));
-  EXPECT_CALL(*session, jid()).WillRepeatedly(ReturnRef(client_jid_));
+void ClientSessionTest::CreateClientSession(
+    std::unique_ptr<protocol::FakeSession> session) {
+  DCHECK(session);
 
   // Mock protocol::ConnectionToClient APIs called directly by ClientSession.
   // HostStub is not touched by ClientSession, so we can safely pass nullptr.
   std::unique_ptr<protocol::FakeConnectionToClient> connection(
       new protocol::FakeConnectionToClient(std::move(session)));
   connection->set_client_stub(&client_stub_);
   connection_ = connection.get();
 
   client_session_.reset(
       new ClientSession(&session_event_handler_, std::move(connection),
                         desktop_environment_factory_.get(),
                         DesktopEnvironmentOptions::CreateDefault(),
                         base::TimeDelta(), nullptr, extensions_));
 }
 
+void ClientSessionTest::CreateClientSession() {
+  CreateClientSession(base::MakeUnique<protocol::FakeSession>());
+}
+
 void ClientSessionTest::ConnectClientSession() {
   EXPECT_CALL(session_event_handler_, OnSessionAuthenticated(_));
   EXPECT_CALL(session_event_handler_, OnSessionChannelsConnected(_));
 
   // Stubs should be set only after connection is authenticated.
   EXPECT_FALSE(connection_->clipboard_stub());
   EXPECT_FALSE(connection_->input_stub());
 
   client_session_->OnConnectionAuthenticated();
 
@@ skipping 218 matching lines @@
   EXPECT_TRUE(extension1.has_handled_message());
 
   // ext2 was instantiated but not sent a message, and wrapped video encoder.
   EXPECT_TRUE(extension2.was_instantiated());
   EXPECT_FALSE(extension2.has_handled_message());
 
   // ext3 was sent a message but not instantiated.
   EXPECT_FALSE(extension3.was_instantiated());
 }
 
+TEST_F(ClientSessionTest, ForwardHostSessionOptions1) {
+  auto session = base::MakeUnique<protocol::FakeSession>();
+  auto configuration = base::MakeUnique<buzz::XmlElement>(
+      buzz::QName(kChromotingXmlNamespace, "host-configuration"));
+  configuration->SetBodyText("Detect-Updated-Region:true");
+  session->SetAttachment(0, std::move(configuration));
+  CreateClientSession(std::move(session));
+  ConnectClientSession();
+  ASSERT_TRUE(desktop_environment_factory_->last_desktop_environment()
+                  ->options()
+                  .desktop_capture_options()
+                  ->detect_updated_region());
+}
+
+TEST_F(ClientSessionTest, ForwardHostSessionOptions2) {
+  auto session = base::MakeUnique<protocol::FakeSession>();
+  auto configuration = base::MakeUnique<buzz::XmlElement>(
+      buzz::QName(kChromotingXmlNamespace, "host-configuration"));
+  configuration->SetBodyText("Detect-Updated-Region:false");
+  session->SetAttachment(0, std::move(configuration));
+  CreateClientSession(std::move(session));
+  ConnectClientSession();
+  ASSERT_FALSE(desktop_environment_factory_->last_desktop_environment()
+                   ->options()
+                   .desktop_capture_options()
+                   ->detect_updated_region());
+}
+
+#if defined(OS_WIN)
+TEST_F(ClientSessionTest, ForwardDirectXHostSessionOptions1) {
+  auto session = base::MakeUnique<protocol::FakeSession>();
+  auto configuration = base::MakeUnique<buzz::XmlElement>(
+      buzz::QName(kChromotingXmlNamespace, "host-configuration"));
+  configuration->SetBodyText("DirectX-Capturer:true");
+  session->SetAttachment(0, std::move(configuration));
+  CreateClientSession(std::move(session));
+  ConnectClientSession();
+  ASSERT_TRUE(desktop_environment_factory_->last_desktop_environment()
+                  ->options()
+                  .desktop_capture_options()
+                  ->allow_directx_capturer());
+}
+
+TEST_F(ClientSessionTest, ForwardDirectXHostSessionOptions2) {
+  auto session = base::MakeUnique<protocol::FakeSession>();
+  auto configuration = base::MakeUnique<buzz::XmlElement>(
+      buzz::QName(kChromotingXmlNamespace, "host-configuration"));
+  configuration->SetBodyText("DirectX-Capturer:false");
+  session->SetAttachment(0, std::move(configuration));
+  CreateClientSession(std::move(session));
+  ConnectClientSession();
+  ASSERT_FALSE(desktop_environment_factory_->last_desktop_environment()
+                   ->options()
+                   .desktop_capture_options()
+                   ->allow_directx_capturer());
+}
+#endif
+
 }  // namespace remoting