cc: Remove some unnecessary const scoped_refptr&.

cc/resources/video_resource_updater.cc

 // Copyright 2013 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 "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 191 matching lines @@
       PlaneResource(resource_id, plane_size, format, mailbox));
   return all_resources_.begin();
 }
 
 void VideoResourceUpdater::DeleteResource(ResourceList::iterator resource_it) {
   DCHECK_EQ(resource_it->ref_count, 0);
   resource_provider_->DeleteResource(resource_it->resource_id);
   all_resources_.erase(resource_it);
 }
 
-VideoFrameExternalResources VideoResourceUpdater::
-    CreateExternalResourcesFromVideoFrame(
-        const scoped_refptr<media::VideoFrame>& video_frame) {
+VideoFrameExternalResources
+VideoResourceUpdater::CreateExternalResourcesFromVideoFrame(
+    scoped_refptr<media::VideoFrame> video_frame) {
 #if defined(VIDEO_HOLE)
   if (video_frame->storage_type() == media::VideoFrame::STORAGE_HOLE) {
     VideoFrameExternalResources external_resources;
     external_resources.type = VideoFrameExternalResources::HOLE;
     return external_resources;
   }
 #endif  // defined(VIDEO_HOLE)
   if (video_frame->format() == media::PIXEL_FORMAT_UNKNOWN)
     return VideoFrameExternalResources();
   DCHECK(video_frame->HasTextures() || video_frame->IsMappable());
   if (video_frame->HasTextures())
-    return CreateForHardwarePlanes(video_frame);
+    return CreateForHardwarePlanes(std::move(video_frame));
   else
-    return CreateForSoftwarePlanes(video_frame);
+    return CreateForSoftwarePlanes(std::move(video_frame));
 }
 
 // For frames that we receive in software format, determine the dimensions of
 // each plane in the frame.
-static gfx::Size SoftwarePlaneDimension(
-    const scoped_refptr<media::VideoFrame>& input_frame,
-    bool software_compositor,
-    size_t plane_index) {
+static gfx::Size SoftwarePlaneDimension(media::VideoFrame* input_frame,
+                                        bool software_compositor,
+                                        size_t plane_index) {
   gfx::Size coded_size = input_frame->coded_size();
   if (software_compositor)
     return coded_size;
 
   int plane_width = media::VideoFrame::Columns(
       plane_index, input_frame->format(), coded_size.width());
   int plane_height = media::VideoFrame::Rows(plane_index, input_frame->format(),
                                              coded_size.height());
   return gfx::Size(plane_width, plane_height);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
-    const scoped_refptr<media::VideoFrame>& video_frame) {
+    scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForSoftwarePlanes");
   const media::VideoPixelFormat input_frame_format = video_frame->format();
 
   // TODO(hubbe): Make this a video frame method.
   int bits_per_channel = 0;
   switch (input_frame_format) {
     case media::PIXEL_FORMAT_UNKNOWN:
       NOTREACHED();
     // Fall through!
     case media::PIXEL_FORMAT_I420:
@@ skipping 52 matching lines @@
     if (it->ref_count == 0 && it->resource_format != output_resource_format)
       DeleteResource(it++);
     else
       ++it;
   }
 
   const int max_resource_size = resource_provider_->max_texture_size();
   std::vector<ResourceList::iterator> plane_resources;
   for (size_t i = 0; i < output_plane_count; ++i) {
     gfx::Size output_plane_resource_size =
-        SoftwarePlaneDimension(video_frame, software_compositor, i);
+        SoftwarePlaneDimension(video_frame.get(), software_compositor, i);
     if (output_plane_resource_size.IsEmpty() ||
         output_plane_resource_size.width() > max_resource_size ||
         output_plane_resource_size.height() > max_resource_size) {
       break;
     }
 
     // Try recycle a previously-allocated resource.
     ResourceList::iterator resource_it = all_resources_.end();
     for (auto it = all_resources_.begin(); it != all_resources_.end(); ++it) {
       if (it->resource_size == output_plane_resource_size &&
@@ skipping 208 matching lines @@
   // returned by the compositor and emit a WaitSyncTokenCHROMIUM on
   // |video_frame|'s previous sync point using the current GL context.
   SyncTokenClientImpl client(updater->context_provider_->ContextGL(),
                              sync_token);
   video_frame->UpdateReleaseSyncToken(&client);
 }
 
 // Create a copy of a texture-backed source video frame in a new GL_TEXTURE_2D
 // texture.
 void VideoResourceUpdater::CopyPlaneTexture(
-    const scoped_refptr<media::VideoFrame>& video_frame,
+    media::VideoFrame* video_frame,
     const gpu::MailboxHolder& mailbox_holder,
     VideoFrameExternalResources* external_resources) {
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   SyncTokenClientImpl client(gl, mailbox_holder.sync_token);
 
   const gfx::Size output_plane_resource_size = video_frame->coded_size();
   // The copy needs to be a direct transfer of pixel data, so we use an RGBA8
   // target to avoid loss of precision or dropping any alpha component.
   const ResourceFormat copy_target_format = ResourceFormat::RGBA_8888;
 
@@ skipping 49 matching lines @@
 
   external_resources->mailboxes.push_back(
       TextureMailbox(resource->mailbox, sync_token, GL_TEXTURE_2D,
                      video_frame->coded_size(), false, false));
 
   external_resources->release_callbacks.push_back(
       base::Bind(&RecycleResource, AsWeakPtr(), resource->resource_id));
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
-    const scoped_refptr<media::VideoFrame>& video_frame) {
+    scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
   DCHECK(video_frame->HasTextures());
   if (!context_provider_)
     return VideoFrameExternalResources();
 
   VideoFrameExternalResources external_resources;
   if (video_frame->metadata()->IsTrue(
           media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED)) {
     external_resources.read_lock_fences_enabled = true;
   }
 
   external_resources.type = ResourceTypeForVideoFrame(video_frame.get());
   if (external_resources.type == VideoFrameExternalResources::NONE) {
     DLOG(ERROR) << "Unsupported Texture format"
                 << media::VideoPixelFormatToString(video_frame->format());
     return external_resources;
   }
 
   const size_t num_planes = media::VideoFrame::NumPlanes(video_frame->format());
   for (size_t i = 0; i < num_planes; ++i) {
     const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(i);
     if (mailbox_holder.mailbox.IsZero())
       break;
 
     if (video_frame->metadata()->IsTrue(
             media::VideoFrameMetadata::COPY_REQUIRED)) {
-      CopyPlaneTexture(video_frame, mailbox_holder, &external_resources);
+      CopyPlaneTexture(video_frame.get(), mailbox_holder, &external_resources);
     } else {
       external_resources.mailboxes.push_back(TextureMailbox(
           mailbox_holder.mailbox, mailbox_holder.sync_token,
           mailbox_holder.texture_target, video_frame->coded_size(),
           video_frame->metadata()->IsTrue(
               media::VideoFrameMetadata::ALLOW_OVERLAY),
           false));
 
       external_resources.release_callbacks.push_back(
           base::Bind(&ReturnTexture, AsWeakPtr(), video_frame));
@@ skipping 32 matching lines @@
     resource_it->ref_count = 0;
     updater->DeleteResource(resource_it);
     return;
   }
 
   --resource_it->ref_count;
   DCHECK_GE(resource_it->ref_count, 0);
 }
 
 }  // namespace cc