Cast: Enable use of VideoEncodeAccelerator for hardware video encoding

chrome/renderer/media/cast_session_delegate.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 "chrome/renderer/media/cast_session_delegate.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chrome/renderer/media/cast_threads.h"
@@ skipping 20 matching lines @@
 
 // Allow 9MB for serialized video / audio event logs.
 const int kMaxSerializedBytes = 9000000;
 
 // Assume serialized log data for each frame will take up to 150 bytes.
 const int kMaxVideoEventEntries = kMaxSerializedBytes / 150;
 
 // Assume serialized log data for each frame will take up to 75 bytes.
 const int kMaxAudioEventEntries = kMaxSerializedBytes / 75;
 
+void CreateVideoEncodeAccelerator(const base::Callback<
+    void(scoped_refptr<base::SingleThreadTaskRunner>,
+         scoped_ptr<media::VideoEncodeAccelerator>)>& callback) {
+  NOTIMPLEMENTED();
+  // Delegate the call to content API on the render thread.
+}
+
+void CreateVideoEncodeMemory(
+    size_t size,
+    const base::Callback<void(scoped_ptr<base::SharedMemory>)>&) {
+  NOTIMPLEMENTED();
+  // Delegate the call to content API on the render thread.
+}
+
 }  // namespace
 
 CastSessionDelegate::CastSessionDelegate()
     : io_message_loop_proxy_(
           content::RenderThread::Get()->GetIOMessageLoopProxy()),
       weak_factory_(this) {
   DCHECK(io_message_loop_proxy_);
 }
 
 CastSessionDelegate::~CastSessionDelegate() {
@@ skipping 45 matching lines @@
     return;
   }
 
   video_frame_input_available_callback_ = callback;
 
   media::cast::transport::CastTransportVideoConfig transport_config;
   transport_config.base.ssrc = config.sender_ssrc;
   transport_config.codec = config.codec;
   transport_config.base.rtp_config = config.rtp_config;
   cast_transport_->InitializeVideo(transport_config);
-  // TODO(mikhal): Pass in a valid GpuVideoAcceleratorFactories to support
-  // hardware video encoding.
   cast_sender_->InitializeVideo(
       config,
       base::Bind(&CastSessionDelegate::InitializationResultCB,
                  weak_factory_.GetWeakPtr()),
-      NULL /* GPU*/);
+      base::Bind(&CreateVideoEncodeAccelerator),
+      base::Bind(&CreateVideoEncodeMemory));
 }
 
 void CastSessionDelegate::StartUDP(const net::IPEndPoint& remote_endpoint) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // Logging: enable raw events and stats collection.
   media::cast::CastLoggingConfig logging_config =
       media::cast::GetLoggingConfigWithRawEventsAndStatsEnabled();
 
   // CastSender uses the renderer's IO thread as the main thread. This reduces
@@ skipping 140 matching lines @@
        ++it) {
     cast_environment_->Logging()->InsertPacketEvent(it->timestamp,
                                                     it->type,
                                                     it->rtp_timestamp,
                                                     it->frame_id,
                                                     it->packet_id,
                                                     it->max_packet_id,
                                                     it->size);
   }
 }