Start using deferred rendering for WebView on L.

media/filters/gpu_video_decoder.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 "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
                                  const RequestSurfaceCB& request_surface_cb)
     : needs_bitstream_conversion_(false),
       factories_(factories),
       state_(kNormal),
       request_surface_cb_(request_surface_cb),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(0),
       needs_all_picture_buffers_to_decode_(false),
+      copy_required_(false),
       weak_factory_(this) {
   DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DVLOG(3) << "Reset()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (state_ == kDrainingDecoder) {
     base::MessageLoop::current()->PostTask(
@@ skipping 80 matching lines @@
     DVLOG(1) << "Profile " << config.profile() << " or coded size "
              << config.coded_size().ToString() << " not supported.";
     bound_init_cb.Run(false);
     return;
   }
 
   config_ = config;
   needs_all_picture_buffers_to_decode_ =
       capabilities.flags &
       VideoDecodeAccelerator::Capabilities::NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
+  copy_required_ = (capabilities.flags &
+                    VideoDecodeAccelerator::Capabilities::COPY_REQUIRED) ==
+                   VideoDecodeAccelerator::Capabilities::COPY_REQUIRED;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
   output_cb_ = BindToCurrentLoop(output_cb);
 
   if (previously_initialized) {
     DVLOG(3) << __FUNCTION__
              << " Expecting initialized VDA to detect in-stream config change.";
     // Reinitialization with a different config (but same codec and profile).
     // VDA should handle it by detecting this in-stream by itself,
     // no need to notify it.
     bound_init_cb.Run(true);
@@ skipping 316 matching lines @@
           &GpuVideoDecoder::ReleaseMailbox, weak_factory_.GetWeakPtr(),
           factories_, picture.picture_buffer_id(), pb.texture_id())),
       pb.size(), visible_rect, natural_size, timestamp));
   if (!frame) {
     DLOG(ERROR) << "Create frame failed for: " << picture.picture_buffer_id();
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   if (picture.allow_overlay())
     frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
+  if (copy_required_)
+    frame->metadata()->SetBoolean(VideoFrameMetadata::COPY_REQUIRED, true);
   CHECK_GT(available_pictures_, 0);
   --available_pictures_;
   bool inserted =
       picture_buffers_at_display_.insert(std::make_pair(
                                              picture.picture_buffer_id(),
                                              pb.texture_id())).second;
   DCHECK(inserted);
 
   DeliverFrame(frame);
 }
@@ skipping 179 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media