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 305 matching lines @@
   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))

[mcasas, 2015/11/13 19:13:57]

Same here, nobody should produce HasTextures() anymore
(except perhaps FakeVCD and it should be adapted too in 
this CL).

[miu, 2015/11/14 03:43:47]

Done.  And, I made these checks a bit stricter to ensure client code doesn't
provide VideoFrames: 1) with an incorrect pixel format or storage type, and 2)
that are not actually backed by the buffer.

         << "Format and/or storage type combination not supported (received: "
         << media::VideoPixelFormatToString(frame->format()) << ")";
 
     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)
@@ skipping 62 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()) {

[mcasas, 2015/11/13 19:13:57]

I think this if() is also unused if noone is going to
produce textures anymore (we can leave a
DCHECK(!frame->HasTextures()) if you want).

[miu, 2015/11/14 03:43:47]

Deleted.

Also, I removed all the DCHECKs() here since this is a private method called
only by DoIncomingCapturedVideoFrameOnIOThread(), which itself does these
checks.

     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) {
+    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);
   } else {
     base::SharedMemoryHandle remote_handle;
     buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
@@ skipping 19 matching lines @@
     int session_id,
     const ControllerClients& clients) {
   for (auto client : clients) {
     if (client->session_id == session_id)
       return client;
   }
   return NULL;
 }
 
 }  // namespace content