Remove dead code paths around PIXEL_STORAGE_TEXTURE in capture pipeline.

media/capture/content/thread_safe_capture_oracle.cc

 // Copyright 2014 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 "media/capture/content/thread_safe_capture_oracle.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/bits.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 37 matching lines @@
   const base::TimeTicks capture_begin_time = base::TimeTicks::Now();
 
   base::AutoLock guard(lock_);
 
   if (!client_)
     return false;  // Capture is stopped.
 
   const bool should_capture =
       oracle_.ObserveEventAndDecideCapture(event, damage_rect, event_time);
   const gfx::Size visible_size = oracle_.capture_size();
-  // Always round up the coded size to multiple of 16 pixels.
-  // See http://crbug.com/402151.
-  const gfx::Size coded_size((visible_size.width() + 15) & ~15,
-                             (visible_size.height() + 15) & ~15);
+  // TODO(miu): Clients should request exact padding, instead of this
+  // memory-wasting hack to make frames that are compatible with all HW
+  // encoders.  http://crbug.com/555911
+  const gfx::Size coded_size(base::bits::Align(visible_size.width(), 16),
+                             base::bits::Align(visible_size.height(), 16));
 
   scoped_ptr<media::VideoCaptureDevice::Client::Buffer> output_buffer(
       client_->ReserveOutputBuffer(coded_size,
-                                   (params_.requested_format.pixel_storage !=
-                                    media::PIXEL_STORAGE_TEXTURE)
-                                       ? media::PIXEL_FORMAT_I420
-                                       : media::PIXEL_FORMAT_ARGB,
+                                   params_.requested_format.pixel_format,
                                    params_.requested_format.pixel_storage));
   // Get the current buffer pool utilization and attenuate it: The utilization
   // reported to the oracle is in terms of a maximum sustainable amount (not the
   // absolute maximum).
   const double attenuated_utilization =
       client_->GetBufferPoolUtilization() *
       (100.0 / kTargetMaxPoolUtilizationPercent);
 
   const char* event_name =
       (event == VideoCaptureOracle::kTimerPoll
@@ skipping 16 matching lines @@
                            TRACE_EVENT_SCOPE_THREAD, "trigger", event_name);
     }
     return false;
   } else if (!should_capture && !output_buffer.get()) {
     // We decided not to capture, but we wouldn't have been able to if we wanted
     // to because no output buffer was available.
     TRACE_EVENT_INSTANT1("gpu.capture", "NearlyPipelineLimited",
                          TRACE_EVENT_SCOPE_THREAD, "trigger", event_name);
     return false;
   }
+
   const int frame_number = oracle_.RecordCapture(attenuated_utilization);
   TRACE_EVENT_ASYNC_BEGIN2("gpu.capture", "Capture", output_buffer.get(),
                            "frame_number", frame_number, "trigger", event_name);
-  // Texture frames wrap a texture mailbox, which we don't have at the moment.
-  // We do not construct those frames.
-  if (params_.requested_format.pixel_storage != media::PIXEL_STORAGE_TEXTURE) {
-    *storage = VideoFrame::WrapExternalData(
-        media::PIXEL_FORMAT_I420, coded_size, gfx::Rect(visible_size),
-        visible_size, static_cast<uint8*>(output_buffer->data()),
-        output_buffer->mapped_size(), base::TimeDelta());
-    DCHECK(*storage);
-  }
+
+  DCHECK_EQ(media::PIXEL_STORAGE_CPU, params_.requested_format.pixel_storage);
+  *storage = VideoFrame::WrapExternalSharedMemory(
+      params_.requested_format.pixel_format, coded_size,
+      gfx::Rect(visible_size), visible_size,
+      static_cast<uint8*>(output_buffer->data()), output_buffer->mapped_size(),
+      base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
+  DCHECK(*storage);
   *callback =
       base::Bind(&ThreadSafeCaptureOracle::DidCaptureFrame, this, frame_number,
                  base::Passed(&output_buffer), capture_begin_time,
                  oracle_.estimated_frame_duration());
   return true;
 }
 
 gfx::Size ThreadSafeCaptureOracle::GetCaptureSize() const {
   base::AutoLock guard(lock_);
   return oracle_.capture_size();
@@ skipping 61 matching lines @@
   // destructor.  |metadata| is still valid for read-access at this point.
   double utilization = -1.0;
   if (metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                           &utilization)) {
     base::AutoLock guard(lock_);
     oracle_.RecordConsumerFeedback(frame_number, utilization);
   }
 }
 
 }  // namespace media