Remove dead code paths around PIXEL_STORAGE_TEXTURE in capture pipeline.

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
 
 using media::VideoCaptureFormat;
 using media::VideoFrame;
 using media::VideoFrameMetadata;
 
@@ skipping 114 matching lines @@
 
 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
            << ", " << params.requested_format.frame_size.ToString()
            << ", " << params.requested_format.frame_rate

[mcasas, 2015/11/17 02:23:47]

Nit: Same as below, consider
media::VideoCaptureFormat::ToString(params.requested_format)
to just print it all.

[miu, 2015/11/17 04:28:02]

Done.

            << ", " << session_id
            << ")";
 
+  // Check that requested VideoCaptureParams are valid and supported.  If not,
+  // report an error immediately and punt.
+  if (!params.IsValid() ||
+      params.requested_format.pixel_format != media::PIXEL_FORMAT_I420 ||
+      (params.requested_format.pixel_storage != media::PIXEL_STORAGE_CPU &&
+       params.requested_format.pixel_storage !=
+           media::PIXEL_STORAGE_GPUMEMORYBUFFER)) {
+    // Crash in debug builds since the renderer should not have asked for
+    // invalid or unsupported parameters.
+    LOG(DFATAL) << "Invalid or unsupported video capture parameters requested: "
+                << "frame_size="
+                << params.requested_format.frame_size.ToString()
+                << ", frame_rate=" << params.requested_format.frame_rate
+                << ", pixel_format=" << media::VideoPixelFormatToString(
+                    params.requested_format.pixel_format)
+                << ", pixel_storage=" << params.requested_format.pixel_storage;

[mcasas, 2015/11/17 02:23:47]

Nit: Consider using [1] 
media::VideoCaptureFormat::ToString(params.requested_format) 

[1] 
https://code.google.com/p/chromium/codesearch#chromium/src/media/base/video_c...

[miu, 2015/11/17 04:28:02]

Done.

+    event_handler->OnError(id);
+    return;
+  }
+
   // If this is the first client added to the controller, cache the parameters.
   if (!controller_clients_.size())
     video_capture_format_ = params.requested_format;
 
   // Signal error in case device is already in error state.
   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
     event_handler->OnError(id);
     return;
   }
 
@@ skipping 165 matching lines @@
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     if (!frame->metadata()->HasKey(VideoFrameMetadata::FRAME_RATE)) {
       frame->metadata()->SetDouble(VideoFrameMetadata::FRAME_RATE,
                                    video_capture_format_.frame_rate);
     }
     scoped_ptr<base::DictionaryValue> metadata(new base::DictionaryValue());
     frame->metadata()->MergeInternalValuesInto(metadata.get());
 
-    DCHECK(
-        (frame->IsMappable() && frame->format() == media::PIXEL_FORMAT_I420) ||
-        (frame->HasTextures() && frame->format() == media::PIXEL_FORMAT_ARGB))
-        << "Format and/or storage type combination not supported (received: "
-        << media::VideoPixelFormatToString(frame->format()) << ")";
+    // Only I420 pixel format is currently supported.
+    DCHECK_EQ(frame->format(), media::PIXEL_FORMAT_I420)
+        << "Unsupported pixel format: "
+        << media::VideoPixelFormatToString(frame->format());
+
+    // Sanity-checks to confirm |frame| is actually being backed by |buffer|.
+    DCHECK(frame->storage_type() == media::VideoFrame::STORAGE_SHMEM ||
+           (frame->storage_type() ==
+                media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS));
+    DCHECK(frame->data(media::VideoFrame::kYPlane) >= buffer->data(0) &&
+           (frame->data(media::VideoFrame::kYPlane) <
+                (reinterpret_cast<const uint8*>(buffer->data(0)) +
+                     buffer->mapped_size())))
+        << "VideoFrame does not appear to be backed by Buffer";
 
     for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
 
       // On the first use of a buffer on a client, share the memory handles.
       const bool is_new_buffer = client->known_buffers.insert(buffer_id).second;
       if (is_new_buffer)
         DoNewBufferOnIOThread(client, buffer.get(), frame);
 
@@ skipping 60 matching lines @@
   }
 }
 
 void VideoCaptureController::DoNewBufferOnIOThread(
     ControllerClient* client,
     media::VideoCaptureDevice::Client::Buffer* buffer,
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const int buffer_id = buffer->id();
 
-  if (frame->HasTextures()) {
-    DCHECK_EQ(frame->format(), media::PIXEL_FORMAT_ARGB);
-    DCHECK(frame->coded_size() == frame->visible_rect().size())
-        << "Textures shouldn't be crop-marked or letterboxed.";
-    return;
-  }
-
-  DCHECK_EQ(frame->format(), media::PIXEL_FORMAT_I420);
-  if (frame->storage_type() == media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS) {
-    std::vector<gfx::GpuMemoryBufferHandle> handles;
-    for (size_t i = 0; i < media::VideoFrame::NumPlanes(frame->format()); ++i) {
-      gfx::GpuMemoryBufferHandle remote_handle;
-      buffer_pool_->ShareToProcess2(buffer_id, i, client->render_process_handle,
-                                    &remote_handle);
-      handles.push_back(remote_handle);
+  switch (frame->storage_type()) {
+    case media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS: {
+      std::vector<gfx::GpuMemoryBufferHandle> handles;
+      const size_t num_planes = media::VideoFrame::NumPlanes(frame->format());
+      for (size_t i = 0; i < num_planes; ++i) {
+        gfx::GpuMemoryBufferHandle remote_handle;
+        buffer_pool_->ShareToProcess2(
+            buffer_id, i, client->render_process_handle, &remote_handle);
+        handles.push_back(remote_handle);
+      }
+      client->event_handler->OnBufferCreated2(client->controller_id, handles,
+                                              buffer->dimensions(), buffer_id);
+      break;
     }
-    client->event_handler->OnBufferCreated2(client->controller_id, handles,
-                                            buffer->dimensions(), buffer_id);
-  } else {
-    base::SharedMemoryHandle remote_handle;
-    buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
-                                 &remote_handle);
-
-    client->event_handler->OnBufferCreated(client->controller_id, remote_handle,
-                                           buffer->mapped_size(), buffer_id);
+    case media::VideoFrame::STORAGE_SHMEM: {
+      base::SharedMemoryHandle remote_handle;
+      buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
+                                   &remote_handle);
+      client->event_handler->OnBufferCreated(
+          client->controller_id, remote_handle, buffer->mapped_size(),
+          buffer_id);
+      break;
+    }
+    default:
+      NOTREACHED();
+      break;
   }
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (auto* client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
       return client;
   }
   return NULL;
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     int session_id,
     const ControllerClients& clients) {
   for (auto client : clients) {
     if (client->session_id == session_id)
       return client;
   }
   return NULL;
 }
 
 }  // namespace content