[Remoting Host] Supporting WebRTC VP9 streaming

remoting/protocol/webrtc_video_stream.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_video_stream.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "remoting/base/constants.h"
 #include "remoting/codec/webrtc_video_encoder_vpx.h"
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/host_video_stats_dispatcher.h"
 #include "remoting/protocol/webrtc_dummy_video_capturer.h"
 #include "remoting/protocol/webrtc_frame_scheduler_simple.h"
@@ skipping 52 matching lines @@
 
   scoped_refptr<webrtc::PeerConnectionFactoryInterface> peer_connection_factory(
       webrtc_transport->peer_connection_factory());
   peer_connection_ = webrtc_transport->peer_connection();
   DCHECK(peer_connection_factory);
   DCHECK(peer_connection_);
 
   encode_task_runner_ = std::move(encode_task_runner);
   capturer_ = std::move(desktop_capturer);
   webrtc_transport_ = webrtc_transport;
-  // TODO(isheriff): make this codec independent
-  encoder_ = WebrtcVideoEncoderVpx::CreateForVP8();
+
+  webrtc_transport_->video_encoder_factory()->RegisterEncoderSelectedCallback(
+      base::Bind(&WebrtcVideoStream::OnEncoderCreated,
+                 weak_factory_.GetWeakPtr()));
+
   capturer_->Start(this);
 
   // Set video stream constraints.
   webrtc::FakeConstraints video_constraints;
   video_constraints.AddMandatory(
       webrtc::MediaConstraintsInterface::kMinFrameRate, 5);
 
   rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> src =
       peer_connection_factory->CreateVideoSource(new WebrtcDummyVideoCapturer(),
                                                  &video_constraints);
@@ skipping 66 matching lines @@
                                : frame->dpi();
 
     if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
       frame_size_ = frame->size();
       frame_dpi_ = dpi;
       if (observer_)
         observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
     }
   }
 
+  DCHECK(encoder_);
+
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&WebrtcVideoStream::EncodeFrame, encoder_.get(),
                  base::Passed(std::move(frame)), frame_params,
                  base::Passed(std::move(captured_frame_stats_))),
       base::Bind(&WebrtcVideoStream::OnFrameEncoded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebrtcVideoStream::OnChannelInitialized(
@@ skipping 77 matching lines @@
 
     stats.encode_delay =
         frame.stats->encode_ended_time - frame.stats->encode_started_time;
 
     stats.capturer_id = frame.stats->capturer_id;
 
     video_stats_dispatcher_.OnVideoFrameStats(result.frame_id, stats);
   }
 }
 
+void WebrtcVideoStream::OnEncoderCreated(webrtc::VideoCodecType codec_type) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (codec_type == webrtc::kVideoCodecVP8) {
+    encoder_ = WebrtcVideoEncoderVpx::CreateForVP8();
+  } else if (codec_type == webrtc::kVideoCodecVP9) {
+    encoder_ = WebrtcVideoEncoderVpx::CreateForVP9();
+  } else {
+    LOG(FATAL) << "Unknown codec type: " << codec_type;
+  }
+}
+
 }  // namespace protocol
 }  // namespace remoting