Revert of VideoCapture: add support for GpuMemoryBuffer allocation and lifetime mgmt in VideoCaptureBufferPool

content/browser/renderer_host/media/video_capture_controller.cc

 // Copyright (c) 2012 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/browser/renderer_host/media/video_capture_controller.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/media/video_capture_device_client.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_frame.h"
 
 #if !defined(OS_ANDROID)
 #include "content/browser/compositor/image_transport_factory.h"
 #endif
 
+#if defined(ENABLE_WEBRTC) && (defined(OS_LINUX) || defined(OS_MACOSX))
+#include "content/browser/renderer_host/media/video_capture_texture_wrapper.h"
+#endif
+
 using media::VideoCaptureFormat;
 using media::VideoFrame;
 
 namespace content {
 
 namespace {
 
 static const int kInfiniteRatio = 99999;
 
 #define UMA_HISTOGRAM_ASPECT_RATIO(name, width, height) \
@@ skipping 91 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 base::WeakPtr<VideoCaptureController>
 VideoCaptureController::GetWeakPtrForIOThread() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 scoped_ptr<media::VideoCaptureDevice::Client>
 VideoCaptureController::NewDeviceClient(
-    const scoped_refptr<base::SingleThreadTaskRunner>& capture_task_runner) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& capture_task_runner,
+    const media::VideoCaptureFormat& format) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return make_scoped_ptr(new VideoCaptureDeviceClient(
-      this->GetWeakPtrForIOThread(), buffer_pool_, capture_task_runner));
+#if defined(ENABLE_WEBRTC) && (defined(OS_LINUX) || defined(OS_MACOSX))
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableWebRtcCaptureToTexture)) {
+    return make_scoped_ptr(new VideoCaptureTextureWrapper(
+        this->GetWeakPtrForIOThread(), buffer_pool_, capture_task_runner,
+        format));
+    DVLOG(1) << "TextureWrapper, format " << format.ToString();
+  }
+#endif
+  return make_scoped_ptr(
+      new VideoCaptureDeviceClient(this->GetWeakPtrForIOThread(),
+                                   buffer_pool_));
 }
 
 void VideoCaptureController::AddClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::AddClient, id " << id
@@ skipping 111 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return video_capture_format_;
 }
 
 VideoCaptureController::~VideoCaptureController() {
   STLDeleteContainerPointers(controller_clients_.begin(),
                              controller_clients_.end());
 }
 
 void VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread(
-    scoped_ptr<media::VideoCaptureDevice::Client::Buffer> buffer,
+    const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer,
     const scoped_refptr<VideoFrame>& frame,
     const base::TimeTicks& timestamp) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  const int buffer_id = buffer->id();
-  DCHECK_NE(buffer_id, VideoCaptureBufferPool::kInvalidId);
+  DCHECK_NE(buffer->id(), VideoCaptureBufferPool::kInvalidId);
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     if (!frame->metadata()->HasKey(media::VideoFrameMetadata::FRAME_RATE)) {
       frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                    video_capture_format_.frame_rate);
     }
     scoped_ptr<base::DictionaryValue> metadata(new base::DictionaryValue());
     frame->metadata()->MergeInternalValuesInto(metadata.get());
 
     for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
 
       scoped_ptr<base::DictionaryValue> copy_of_metadata;
       if (client == controller_clients_.back())
         copy_of_metadata = metadata.Pass();
       else
         copy_of_metadata.reset(metadata->DeepCopy());
 
       if (frame->format() == VideoFrame::NATIVE_TEXTURE) {
         DCHECK(frame->coded_size() == frame->visible_rect().size())
             << "Textures are always supposed to be tightly packed.";
         client->event_handler->OnMailboxBufferReady(client->controller_id,
-                                                    buffer_id,
+                                                    buffer->id(),
                                                     *frame->mailbox_holder(),
                                                     frame->coded_size(),
                                                     timestamp,
                                                     copy_of_metadata.Pass());
       } else if (frame->format() == media::VideoFrame::I420) {
-        bool is_new_buffer = client->known_buffers.insert(buffer_id).second;
+        bool is_new_buffer = client->known_buffers.insert(buffer->id()).second;
         if (is_new_buffer) {
           // On the first use of a buffer on a client, share the memory handle.
           size_t memory_size = 0;
           base::SharedMemoryHandle remote_handle = buffer_pool_->ShareToProcess(
-              buffer_id, client->render_process_handle, &memory_size);
+              buffer->id(), client->render_process_handle, &memory_size);
           client->event_handler->OnBufferCreated(
-              client->controller_id, remote_handle, memory_size, buffer_id);
+              client->controller_id, remote_handle, memory_size, buffer->id());
         }
 
         client->event_handler->OnBufferReady(
-            client->controller_id, buffer_id, frame->coded_size(),
+            client->controller_id, buffer->id(), frame->coded_size(),
             frame->visible_rect(), timestamp, copy_of_metadata.Pass());
       } else {
         // VideoFrame format not supported.
         NOTREACHED();
         break;
       }
 
       bool inserted =
-          client->active_buffers.insert(std::make_pair(buffer_id, frame))
+          client->active_buffers.insert(std::make_pair(buffer->id(), frame))
               .second;
-      DCHECK(inserted) << "Unexpected duplicate buffer: " << buffer_id;
+      DCHECK(inserted) << "Unexpected duplicate buffer: " << buffer->id();
       count++;
     }
   }
 
   if (!has_received_frames_) {
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.Width",
                          frame->visible_rect().width());
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.Height",
                          frame->visible_rect().height());
     UMA_HISTOGRAM_ASPECT_RATIO("Media.VideoCapture.AspectRatio",
                                frame->visible_rect().width(),
                                frame->visible_rect().height());
     double frame_rate;
     if (!frame->metadata()->GetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                       &frame_rate))
       frame_rate = video_capture_format_.frame_rate;
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.FrameRate", frame_rate);
     has_received_frames_ = true;
   }
 
-  buffer_pool_->HoldForConsumers(buffer_id, count);
+  buffer_pool_->HoldForConsumers(buffer->id(), count);
 }
 
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_ERROR;
 
   for (const auto* client : controller_clients_) {
     if (client->session_closed)
        continue;
     client->event_handler->OnError(client->controller_id);
@@ skipping 50 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int active_client_count = 0;
   for (ControllerClient* client : controller_clients_) {
     if (!client->paused)
       ++active_client_count;
   }
   return active_client_count;
 }
 
 }  // namespace content