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   // HostExtensionSession interface.
  23   virtual void OnCreateVideoCapturer(
  24       scoped_ptr<webrtc::DesktopCapturer>* encoder) OVERRIDE;
  25   virtual void OnCreateVideoEncoder(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 void FakeExtension::Session::OnCreateVideoCapturer(
  46     scoped_ptr<webrtc::DesktopCapturer>* capturer) {
  47   extension_->has_wrapped_video_capturer_ = true;
  48   if (extension_->steal_video_capturer_) {
  49     capturer->reset();
  50   }
  51 }
  52
  53 void FakeExtension::Session::OnCreateVideoEncoder(
  54     scoped_ptr<VideoEncoder>* encoder) {
  55   extension_->has_wrapped_video_encoder_ = true;
  56 }
  57
  58 bool FakeExtension::Session::ModifiesVideoPipeline() const {
  59   return extension_->steal_video_capturer_;
  60 }
  61
  62 bool FakeExtension::Session::OnExtensionMessage(
  63     ClientSessionControl* client_session_control,
  64     protocol::ClientStub* client_stub,
  65     const protocol::ExtensionMessage& message) {
  66   if (message.type() == message_type_) {
  67     extension_->has_handled_message_ = true;
  68     return true;
  69   }
  70   return false;
  71 }
  72
  73 FakeExtension::FakeExtension(const std::string& message_type,
  74                              const std::string& capability)
  75   : message_type_(message_type),
  76     capability_(capability),
  77     steal_video_capturer_(false),
  78     has_handled_message_(false),
  79     has_wrapped_video_encoder_(false),
  80     has_wrapped_video_capturer_(false),
  81     was_instantiated_(false) {
  82 }
  83
  84 FakeExtension::~FakeExtension() {
  85 }
  86
  87 std::string FakeExtension::capability() const {
  88   return capability_;
  89 }
  90
  91 scoped_ptr<HostExtensionSession> FakeExtension::CreateExtensionSession(
  92     ClientSessionControl* client_session_control,
  93     protocol::ClientStub* client_stub) {
  94   DCHECK(!was_instantiated());
  95   was_instantiated_ = true;
  96   scoped_ptr<HostExtensionSession> session(new Session(this, message_type_));
  97   return session.Pass();
  98 }
  99
 100 } // namespace remoting