Revert of Revert of Revert of Remove threading from RendererGpuVideoAcceleratorFactories

content/renderer/media/rtc_video_encoder_factory.cc

 // Copyright 2013 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 "content/renderer/media/rtc_video_encoder_factory.h"
 
 #include "content/common/gpu/client/gpu_video_encode_accelerator_host.h"
+#include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
 #include "content/renderer/media/rtc_video_encoder.h"
-#include "media/filters/gpu_video_accelerator_factories.h"
 #include "media/video/video_encode_accelerator.h"
 
 namespace content {
 
 namespace {
 
 // Translate from media::VideoEncodeAccelerator::SupportedProfile to
 // cricket::WebRtcVideoEncoderFactory::VideoCodec
 cricket::WebRtcVideoEncoderFactory::VideoCodec VEAToWebRTCCodec(
     const media::VideoEncodeAccelerator::SupportedProfile& profile) {
@@ skipping 32 matching lines @@
     case webrtc::kVideoCodecGeneric:
       return media::H264PROFILE_MAIN;
     default:
       return media::VIDEO_CODEC_PROFILE_UNKNOWN;
   }
 }
 
 }  // anonymous namespace
 
 RTCVideoEncoderFactory::RTCVideoEncoderFactory(
-    const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories)
+    const scoped_refptr<RendererGpuVideoAcceleratorFactories>& gpu_factories)
     : gpu_factories_(gpu_factories) {
   // Query media::VideoEncodeAccelerator (statically) for our supported codecs.
   std::vector<media::VideoEncodeAccelerator::SupportedProfile> profiles =
       GpuVideoEncodeAcceleratorHost::GetSupportedProfiles();
   for (size_t i = 0; i < profiles.size(); ++i) {
     VideoCodec codec = VEAToWebRTCCodec(profiles[i]);
     if (codec.type != webrtc::kVideoCodecUnknown)
       codecs_.push_back(codec);
   }
 }
 
 RTCVideoEncoderFactory::~RTCVideoEncoderFactory() {}
 
 webrtc::VideoEncoder* RTCVideoEncoderFactory::CreateVideoEncoder(
     webrtc::VideoCodecType type) {
   bool found = false;
   for (size_t i = 0; i < codecs_.size(); ++i) {
     if (codecs_[i].type == type) {
       found = true;
       break;
     }
   }
   if (!found)
     return NULL;
+  // GpuVideoAcceleratorFactories is not thread safe. It cannot be shared
+  // by different encoders. Since we aren't running on the child thread and
+  // cannot create a new factory, clone one instead.
   return new RTCVideoEncoder(
-      type, WebRTCCodecToVideoCodecProfile(type), gpu_factories_);
+      type, WebRTCCodecToVideoCodecProfile(type), gpu_factories_->Clone());
 }
 
 void RTCVideoEncoderFactory::AddObserver(Observer* observer) {
   // No-op: our codec list is populated on installation.
 }
 
 void RTCVideoEncoderFactory::RemoveObserver(Observer* observer) {}
 
 const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>&
 RTCVideoEncoderFactory::codecs() const {
   return codecs_;
 }
 
 void RTCVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   delete encoder;
 }
 
 }  // namespace content