Interface with webrtc through encoded frames

remoting/protocol/webrtc_transport.cc

 // Copyright 2015 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/protocol/webrtc_transport.h"
 
+#include <string>
 #include <utility>
+#include <vector>
 
 #include "base/base64.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/port_allocator_factory.h"
 #include "remoting/protocol/stream_message_pipe_adapter.h"
 #include "remoting/protocol/transport_context.h"
+#include "remoting/protocol/webrtc_video_encoder.h"
 #include "third_party/webrtc/api/test/fakeconstraints.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/modules/audio_device/include/fake_audio_device.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
@@ skipping 80 matching lines @@
 
   void OnSuccess() override {
     base::ResetAndReturn(&result_callback_).Run(true, std::string());
   }
 
   void OnFailure(const std::string& error) override {
     base::ResetAndReturn(&result_callback_).Run(false, error);
   }
 
  protected:
-  SetSessionDescriptionObserver(const ResultCallback& result_callback)
+  explicit SetSessionDescriptionObserver(const ResultCallback& result_callback)
       : result_callback_(result_callback) {}
   ~SetSessionDescriptionObserver() override {}
 
  private:
   ResultCallback result_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSessionDescriptionObserver);
 };
 
 
@@ skipping 30 matching lines @@
   // TODO(sergeyu): Investigate if it's possible to avoid Send().
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
 
   send_transport_info_callback_ = std::move(send_transport_info_callback);
 
   if (!handshake_hmac_.Init(authenticator->GetAuthKey())) {
     LOG(FATAL) << "HMAC::Init() failed.";
   }
 
   fake_audio_device_module_.reset(new webrtc::FakeAudioDeviceModule());
+  video_encoder_factory_ = new remoting::WebRtcVideoEncoderFactory();
 
+  // Takes ownership of video_encoder_factory_
   peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
-      worker_thread_, rtc::Thread::Current(),
-      fake_audio_device_module_.get(), nullptr, nullptr);
+      worker_thread_, rtc::Thread::Current(), fake_audio_device_module_.get(),
+      video_encoder_factory_, nullptr);
 
   webrtc::PeerConnectionInterface::IceServer stun_server;
   stun_server.urls.push_back("stun:stun.l.google.com:19302");
   webrtc::PeerConnectionInterface::RTCConfiguration rtc_config;
   rtc_config.servers.push_back(stun_server);
 
   webrtc::FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            webrtc::MediaConstraintsInterface::kValueTrue);
 
@@ skipping 53 matching lines @@
 #if !defined(NDEBUG)
       ignore_error = base::CommandLine::ForCurrentProcess()->HasSwitch(
           kDisableAuthenticationSwitchName);
 #endif
       if (!ignore_error) {
         Close(AUTHENTICATION_FAILED);
         return true;
       }
     }
 
+    // TODO(isheriff): The need for this should go away once we have a proper
+    // API to provide max bitrate for the case of handing over encoded
+    // frames to webrtc.
+    // Increase max bitrate from 600 kbps to 5 Mbps.
+    std::string vp8line = "a=rtpmap:100 VP8/90000\n";
+    std::string vp8line_with_bitrate =
+        vp8line + "a=fmtp:100 x-google-max-bitrate=5000\n";
+    base::ReplaceSubstringsAfterOffset(&sdp, 0, vp8line, vp8line_with_bitrate);
+
     webrtc::SdpParseError error;
     std::unique_ptr<webrtc::SessionDescriptionInterface> session_description(
         webrtc::CreateSessionDescription(type, sdp, &error));
     if (!session_description) {
       LOG(ERROR) << "Failed to parse the session description: "
                  << error.description << " line: " << error.line;
       return false;
     }
 
     peer_connection_->SetRemoteDescription(
@@ skipping 288 matching lines @@
   peer_connection_->Close();
   peer_connection_ = nullptr;
   peer_connection_factory_ = nullptr;
 
   if (error != OK)
     event_handler_->OnWebrtcTransportError(error);
 }
 
 }  // namespace protocol
 }  // namespace remoting