remoting/host/fake_host_extension.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/host/fake_host_extension.h"
   6
   7 #include <string>
   8
   9 #include "base/logging.h"
  10 #include "remoting/codec/video_encoder.h"
  11 #include "remoting/host/host_extension_session.h"
  12 #include "remoting/proto/control.pb.h"
  13 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
  14
  15 namespace remoting {
  16
  17 class FakeExtension::Session : public HostExtensionSession {
  18  public:
  19   Session(FakeExtension* extension, const std::string& message_type);
  20   virtual ~Session() {}
  21
  22   virtual scoped_ptr<webrtc::DesktopCapturer> OnCreateVideoCapturer(
  23       scoped_ptr<webrtc::DesktopCapturer> encoder) OVERRIDE;
  24   virtual scoped_ptr<VideoEncoder> OnCreateVideoEncoder(
  25       scoped_ptr<VideoEncoder> encoder) OVERRIDE;
  26   virtual bool ModifiesVideoPipeline() const OVERRIDE;
  27   virtual bool OnExtensionMessage(
  28       ClientSessionControl* client_session_control,
  29       protocol::ClientStub* client_stub,
  30       const protocol::ExtensionMessage& message) OVERRIDE;
  31
  32  private:
  33   FakeExtension* extension_;
  34   std::string message_type_;
  35
  36   DISALLOW_COPY_AND_ASSIGN(Session);
  37 };
  38
  39 FakeExtension::Session::Session(
  40     FakeExtension* extension, const std::string& message_type)
  41   : extension_(extension),
  42     message_type_(message_type) {
  43 }
  44
  45 scoped_ptr<webrtc::DesktopCapturer>
  46 FakeExtension::Session::OnCreateVideoCapturer(
  47     scoped_ptr<webrtc::DesktopCapturer> capturer) {
  48   extension_->has_wrapped_video_capturer_ = true;
  49   if (extension_->steal_video_capturer_) {
  50     capturer.reset();
  51   }
  52   return capturer.Pass();
  53 }
  54
  55 scoped_ptr<VideoEncoder> FakeExtension::Session::OnCreateVideoEncoder(
  56     scoped_ptr<VideoEncoder> encoder) {
  57   extension_->has_wrapped_video_encoder_ = true;
  58   return encoder.Pass();
  59 }
  60
  61 bool FakeExtension::Session::ModifiesVideoPipeline() const {
  62   return extension_->steal_video_capturer_;
  63 }
  64
  65 bool FakeExtension::Session::OnExtensionMessage(
  66     ClientSessionControl* client_session_control,
  67     protocol::ClientStub* client_stub,
  68     const protocol::ExtensionMessage& message) {
  69   if (message.type() == message_type_) {
  70     extension_->has_handled_message_ = true;
  71     return true;
  72   }
  73   return false;
  74 }
  75
  76 FakeExtension::FakeExtension(const std::string& message_type,
  77                              const std::string& capability)
  78   : message_type_(message_type),
  79     capability_(capability),
  80     steal_video_capturer_(false),
  81     has_handled_message_(false),
  82     has_wrapped_video_encoder_(false),
  83     has_wrapped_video_capturer_(false),
  84     was_instantiated_(false) {
  85 }
  86
  87 FakeExtension::~FakeExtension() {
  88 }
  89
  90 std::string FakeExtension::capability() const {
  91   return capability_;
  92 }
  93
  94 scoped_ptr<HostExtensionSession> FakeExtension::CreateExtensionSession(
  95     ClientSessionControl* client_session_control,
  96     protocol::ClientStub* client_stub) {
  97   DCHECK(!was_instantiated());
  98   was_instantiated_ = true;
  99   scoped_ptr<HostExtensionSession> session(new Session(this, message_type_));
 100   return session.Pass();
 101 }
 102
 103 void FakeExtension::set_steal_video_capturer(bool steal_video_capturer) {
 104   steal_video_capturer_ = steal_video_capturer;
 105 }
 106
 107 bool FakeExtension::has_wrapped_video_encoder() {
 108   DCHECK(was_instantiated());
 109   return has_wrapped_video_encoder_;
 110 }
 111
 112 bool FakeExtension::has_wrapped_video_capturer() {
 113   DCHECK(was_instantiated());
 114   return has_wrapped_video_capturer_;
 115 }
 116
 117 bool FakeExtension::has_handled_message() {
 118   DCHECK(was_instantiated());
 119   return has_handled_message_;
 120 }
 121
 122 } // namespace remoting