Paint first frame faster, don't crash with no frames during EOS.

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>
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
-#if DCHECK_IS_ON()
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-#endif
-
 namespace cc {
 
 namespace {
 
 const ResourceFormat kRGBResourceFormat = RGBA_8888;
 
 VideoFrameExternalResources::ResourceType ResourceTypeForVideoFrame(
     media::VideoFrame* video_frame) {
   switch (video_frame->format()) {
     case media::PIXEL_FORMAT_ARGB:
@@ skipping 75 matching lines @@
         sync_token_.Clear();
       }
     }
   }
 
  private:
   gpu::gles2::GLES2Interface* gl_;
   gpu::SyncToken sync_token_;
 };
 
-#if DCHECK_IS_ON()
-void OnVideoFrameDestruct(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    const base::Closure& task) {
-  task_runner->PostTask(FROM_HERE, task);
-}
-#endif
-
 }  // namespace
 
 VideoResourceUpdater::PlaneResource::PlaneResource(
     unsigned int resource_id,
     const gfx::Size& resource_size,
     ResourceFormat resource_format,
     gpu::Mailbox mailbox)
-    : resource_id(resource_id),
-      resource_size(resource_size),
-      resource_format(resource_format),
-      mailbox(mailbox),
-      ref_count(0),
-      frame_ptr(nullptr),
-#if DCHECK_IS_ON()
-      destructed(false),
-#endif
-      plane_index(0u) {
-}
+    : resource_id_(resource_id),
+      resource_size_(resource_size),
+      resource_format_(resource_format),
+      mailbox_(mailbox) {}
 
 VideoResourceUpdater::PlaneResource::PlaneResource(const PlaneResource& other) =
     default;
 
-bool VideoResourceUpdater::PlaneResourceMatchesUniqueID(
-    const PlaneResource& plane_resource,
-    const media::VideoFrame* video_frame,
-    size_t plane_index) {
-  bool matched = plane_resource.frame_ptr == video_frame &&
-                 plane_resource.plane_index == plane_index &&
-                 plane_resource.timestamp == video_frame->timestamp();
-#if DCHECK_IS_ON()
-  if ((plane_index == 0) && matched) {
-    DCHECK(!plane_resource.destructed)
-        << "ERROR: reused the destructed resource."
-        << " timestamp = " << plane_resource.timestamp;
-  }
-#endif
-  return matched;
+bool VideoResourceUpdater::PlaneResource::Matches(int unique_frame_id,
+                                                  size_t plane_index) {
+  return has_unique_frame_id_and_plane_index_ &&
+         unique_frame_id_ == unique_frame_id && plane_index_ == plane_index;
 }
 
-void VideoResourceUpdater::SetPlaneResourceUniqueId(
-    const media::VideoFrame* video_frame,
-    size_t plane_index,
-    PlaneResource* plane_resource) {
-  plane_resource->frame_ptr = video_frame;
-  plane_resource->plane_index = plane_index;
-  plane_resource->timestamp = video_frame->timestamp();
-#if DCHECK_IS_ON()
-  plane_resource->destructed = false;
-#endif
+void VideoResourceUpdater::PlaneResource::SetUniqueId(int unique_frame_id,
+                                                      size_t plane_index) {
+  DCHECK_EQ(ref_count_, 1);
+  plane_index_ = plane_index;
+  unique_frame_id_ = unique_frame_id;
+  has_unique_frame_id_and_plane_index_ = true;
 }
 
 VideoFrameExternalResources::VideoFrameExternalResources()
     : type(NONE),
       read_lock_fences_enabled(false),
       offset(0.0f),
       multiplier(1.0f) {}
 
 VideoFrameExternalResources::VideoFrameExternalResources(
     const VideoFrameExternalResources& other) = default;
 
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
 VideoResourceUpdater::VideoResourceUpdater(ContextProvider* context_provider,
                                            ResourceProvider* resource_provider)
     : context_provider_(context_provider),
       resource_provider_(resource_provider) {
 }
 
 VideoResourceUpdater::~VideoResourceUpdater() {
   for (const PlaneResource& plane_resource : all_resources_)
-    resource_provider_->DeleteResource(plane_resource.resource_id);
+    resource_provider_->DeleteResource(plane_resource.resource_id());
 }
 
 VideoResourceUpdater::ResourceList::iterator
 VideoResourceUpdater::AllocateResource(const gfx::Size& plane_size,
                                        ResourceFormat format,
                                        bool has_mailbox,
                                        bool immutable_hint) {
   // TODO(danakj): Abstract out hw/sw resource create/delete from
   // ResourceProvider and stop using ResourceProvider in this class.
   const ResourceId resource_id = resource_provider_->CreateResource(
@@ skipping 15 matching lines @@
         lock.texture_id(),
         resource_provider_->GetResourceTextureTarget(resource_id),
         mailbox.name);
   }
   all_resources_.push_front(
       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);
+  DCHECK(!resource_it->has_refs());
+  resource_provider_->DeleteResource(resource_it->resource_id());
   all_resources_.erase(resource_it);
 }
 
 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;
@@ skipping 82 matching lines @@
   // conversion here. That involves an extra copy of each frame to a bitmap.
   // Obviously, this is suboptimal and should be addressed once ubercompositor
   // starts shaping up.
   if (software_compositor) {
     output_resource_format = kRGBResourceFormat;
     output_plane_count = 1;
   }
 
   // Drop recycled resources that are the wrong format.
   for (auto it = all_resources_.begin(); it != all_resources_.end();) {
-    if (it->ref_count == 0 && it->resource_format != output_resource_format)
+    if (!it->has_refs() && 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.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 &&
-          it->resource_format == output_resource_format) {
-        if (PlaneResourceMatchesUniqueID(*it, video_frame.get(), i)) {
+      if (it->resource_size() == output_plane_resource_size &&
+          it->resource_format() == output_resource_format) {
+        if (it->Matches(video_frame->unique_id(), i)) {
           // Bingo, we found a resource that already contains the data we are
           // planning to put in it. It's safe to reuse it even if
           // resource_provider_ holds some references to it, because those
           // references are read-only.
           resource_it = it;
           break;
         }
 
         // This extra check is needed because resources backed by SharedMemory
         // are not ref-counted, unlike mailboxes. Full discussion in
         // codereview.chromium.org/145273021.
         const bool in_use =
             software_compositor &&
-            resource_provider_->InUseByConsumer(it->resource_id);
-        if (it->ref_count == 0 && !in_use) {
+            resource_provider_->InUseByConsumer(it->resource_id());
+        if (!it->has_refs() && !in_use) {
           // We found a resource with the correct size that we can overwrite.
           resource_it = it;
         }
       }
     }
 
     // Check if we need to allocate a new resource.
     if (resource_it == all_resources_.end()) {
       const bool is_immutable = true;
       resource_it =
           AllocateResource(output_plane_resource_size, output_resource_format,
                            !software_compositor, is_immutable);
     }
     if (resource_it == all_resources_.end())
       break;
 
-    ++resource_it->ref_count;
+    resource_it->add_ref();
     plane_resources.push_back(resource_it);
   }
 
   if (plane_resources.size() != output_plane_count) {
     // Allocation failed, nothing will be returned so restore reference counts.
     for (ResourceList::iterator resource_it : plane_resources)
-      --resource_it->ref_count;
+      resource_it->remove_ref();
     return VideoFrameExternalResources();
   }
 
   VideoFrameExternalResources external_resources;
 
   if (software_compositor) {
     DCHECK_EQ(plane_resources.size(), 1u);
     PlaneResource& plane_resource = *plane_resources[0];
-    DCHECK_EQ(plane_resource.resource_format, kRGBResourceFormat);
-    DCHECK(plane_resource.mailbox.IsZero());
+    DCHECK_EQ(plane_resource.resource_format(), kRGBResourceFormat);
+    DCHECK(plane_resource.mailbox().IsZero());
 
-    if (!PlaneResourceMatchesUniqueID(plane_resource, video_frame.get(), 0)) {
+    if (!plane_resource.Matches(video_frame->unique_id(), 0)) {
       // We need to transfer data from |video_frame| to the plane resource.
       if (!video_renderer_)
         video_renderer_.reset(new media::SkCanvasVideoRenderer);
 
       ResourceProvider::ScopedWriteLockSoftware lock(
-          resource_provider_, plane_resource.resource_id);
+          resource_provider_, plane_resource.resource_id());
       SkCanvas canvas(lock.sk_bitmap());
       // This is software path, so canvas and video_frame are always backed
       // by software.
       video_renderer_->Copy(video_frame, &canvas, media::Context3D());
-      SetPlaneResourceUniqueId(video_frame.get(), 0, &plane_resource);
-#if DCHECK_IS_ON()
-      // Add VideoFrame destructor callback.
-      video_frame->AddDestructionObserver(base::Bind(
-          &OnVideoFrameDestruct, base::ThreadTaskRunnerHandle::Get(),
-          base::Bind(&VideoResourceUpdater::MarkOldResource, AsWeakPtr(),
-                     base::Unretained(video_frame.get()),
-                     video_frame->timestamp())));
-#endif
+      plane_resource.SetUniqueId(video_frame->unique_id(), 0);
     }
 
-    external_resources.software_resources.push_back(plane_resource.resource_id);
+    external_resources.software_resources.push_back(
+        plane_resource.resource_id());
     external_resources.software_release_callback =
-        base::Bind(&RecycleResource, AsWeakPtr(), plane_resource.resource_id);
+        base::Bind(&RecycleResource, AsWeakPtr(), plane_resource.resource_id());
     external_resources.type = VideoFrameExternalResources::SOFTWARE_RESOURCE;
     return external_resources;
   }
 
   for (size_t i = 0; i < plane_resources.size(); ++i) {
     PlaneResource& plane_resource = *plane_resources[i];
     // Update each plane's resource id with its content.
-    DCHECK_EQ(plane_resource.resource_format,
+    DCHECK_EQ(plane_resource.resource_format(),
               resource_provider_->YuvResourceFormat(bits_per_channel));
 
-    if (!PlaneResourceMatchesUniqueID(plane_resource, video_frame.get(), i)) {
+    if (!plane_resource.Matches(video_frame->unique_id(), i)) {
       // We need to transfer data from |video_frame| to the plane resource.
       // TODO(reveman): Can use GpuMemoryBuffers here to improve performance.
 
       // The |resource_size_pixels| is the size of the resource we want to
       // upload to.
-      gfx::Size resource_size_pixels = plane_resource.resource_size;
+      gfx::Size resource_size_pixels = plane_resource.resource_size();
       // The |video_stride_bytes| is the width of the video frame we are
       // uploading (including non-frame data to fill in the stride).
       int video_stride_bytes = video_frame->stride(i);
 
       size_t bytes_per_row = ResourceUtil::UncheckedWidthInBytes<size_t>(
-          resource_size_pixels.width(), plane_resource.resource_format);
+          resource_size_pixels.width(), plane_resource.resource_format());
       // Use 4-byte row alignment (OpenGL default) for upload performance.
       // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
       size_t upload_image_stride =
           MathUtil::UncheckedRoundUp<size_t>(bytes_per_row, 4u);
 
       bool needs_conversion = false;
       int shift = 0;
 
       // LUMINANCE_F16 uses half-floats, so we always need a conversion step.
-      if (plane_resource.resource_format == LUMINANCE_F16) {
+      if (plane_resource.resource_format() == LUMINANCE_F16) {
         needs_conversion = true;
         // Note that the current method of converting integers to half-floats
         // stops working if you have more than 10 bits of data.
         DCHECK_LE(bits_per_channel, 10);
       } else if (bits_per_channel > 8) {
         // If bits_per_channel > 8 and we can't use LUMINANCE_F16, we need to
         // shift the data down and create an 8-bit texture.
         needs_conversion = true;
         shift = bits_per_channel - 8;
       }
       const uint8_t* pixels;
       if (static_cast<int>(upload_image_stride) == video_stride_bytes &&
           !needs_conversion) {
         pixels = video_frame->data(i);
       } else {
         // Avoid malloc for each frame/plane if possible.
         size_t needed_size =
             upload_image_stride * resource_size_pixels.height();
         if (upload_pixels_.size() < needed_size)
           upload_pixels_.resize(needed_size);
 
         for (int row = 0; row < resource_size_pixels.height(); ++row) {
-          if (plane_resource.resource_format == LUMINANCE_F16) {
+          if (plane_resource.resource_format() == LUMINANCE_F16) {
             uint16_t* dst = reinterpret_cast<uint16_t*>(
                 &upload_pixels_[upload_image_stride * row]);
             const uint16_t* src = reinterpret_cast<uint16_t*>(
                 video_frame->data(i) + (video_stride_bytes * row));
             // Micro-benchmarking indicates that the compiler does
             // a good enough job of optimizing this loop that trying
             // to manually operate on one uint64 at a time is not
             // actually helpful.
             // Note to future optimizers: Benchmark your optimizations!
             for (size_t i = 0; i < bytes_per_row / 2; i++)
@@ skipping 11 matching lines @@
             // differ in stride, copy one row at a time.
             uint8_t* dst = &upload_pixels_[upload_image_stride * row];
             const uint8_t* src =
                 video_frame->data(i) + (video_stride_bytes * row);
             memcpy(dst, src, bytes_per_row);
           }
         }
         pixels = &upload_pixels_[0];
       }
 
-      resource_provider_->CopyToResource(plane_resource.resource_id, pixels,
+      resource_provider_->CopyToResource(plane_resource.resource_id(), pixels,
                                          resource_size_pixels);
-      SetPlaneResourceUniqueId(video_frame.get(), i, &plane_resource);
-#if DCHECK_IS_ON()
-      // Add VideoFrame destructor callback.
-      if (i == 0) {
-        video_frame->AddDestructionObserver(base::Bind(
-            &OnVideoFrameDestruct, base::ThreadTaskRunnerHandle::Get(),
-            base::Bind(&VideoResourceUpdater::MarkOldResource, AsWeakPtr(),
-                       base::Unretained(video_frame.get()),
-                       video_frame->timestamp())));
-      }
-#endif
+      plane_resource.SetUniqueId(video_frame->unique_id(), i);
     }
 
-    if (plane_resource.resource_format == LUMINANCE_F16) {
+    if (plane_resource.resource_format() == LUMINANCE_F16) {
       // By OR-ing with 0x3800, 10-bit numbers become half-floats in the
       // range [0.5..1) and 9-bit numbers get the range [0.5..0.75).
       //
       // Half-floats are evaluated as:
       // float value = pow(2.0, exponent - 25) * (0x400 + fraction);
       //
       // In our case the exponent is 14 (since we or with 0x3800) and
       // pow(2.0, 14-25) * 0x400 evaluates to 0.5 (our offset) and
       // pow(2.0, 14-25) * fraction is [0..0.49951171875] for 10-bit and
       // [0..0.24951171875] for 9-bit.
       //
       // (https://en.wikipedia.org/wiki/Half-precision_floating-point_format)
       //
       // PLEASE NOTE: This doesn't work if bits_per_channel is > 10.
       // PLEASE NOTE: All planes are assumed to use the same multiplier/offset.
       external_resources.offset = 0.5f;
       // Max value from input data.
       int max_input_value = (1 << bits_per_channel) - 1;
       // 2 << 11 = 2048 would be 1.0 with our exponent.
       external_resources.multiplier = 2048.0 / max_input_value;
     }
 
     external_resources.mailboxes.push_back(
-        TextureMailbox(plane_resource.mailbox, gpu::SyncToken(),
+        TextureMailbox(plane_resource.mailbox(), gpu::SyncToken(),
                        resource_provider_->GetResourceTextureTarget(
-                           plane_resource.resource_id)));
-    external_resources.release_callbacks.push_back(
-        base::Bind(&RecycleResource, AsWeakPtr(), plane_resource.resource_id));
+                           plane_resource.resource_id())));
+    external_resources.release_callbacks.push_back(base::Bind(
+        &RecycleResource, AsWeakPtr(), plane_resource.resource_id()));
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::ReturnTexture(
     base::WeakPtr<VideoResourceUpdater> updater,
     const scoped_refptr<media::VideoFrame>& video_frame,
@@ skipping 25 matching lines @@
   // 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;
 
   // Search for an existing resource to reuse.
   VideoResourceUpdater::ResourceList::iterator resource = all_resources_.end();
 
   for (auto it = all_resources_.begin(); it != all_resources_.end(); ++it) {
     // Reuse resource if attributes match and the resource is a currently
     // unreferenced texture.
-    if (it->resource_size == output_plane_resource_size &&
-        it->resource_format == copy_target_format && !it->mailbox.IsZero() &&
-        it->ref_count == 0 &&
-        resource_provider_->GetTextureHint(it->resource_id) !=
+    if (it->resource_size() == output_plane_resource_size &&
+        it->resource_format() == copy_target_format &&
+        !it->mailbox().IsZero() && !it->has_refs() &&
+        resource_provider_->GetTextureHint(it->resource_id()) !=
             ResourceProvider::TEXTURE_HINT_IMMUTABLE) {
       resource = it;
       break;
     }
   }
 
   // Otherwise allocate a new resource.
   if (resource == all_resources_.end()) {
     const bool is_immutable = false;
     resource = AllocateResource(output_plane_resource_size, copy_target_format,
                                 true, is_immutable);
   }
 
-  ++resource->ref_count;
+  resource->add_ref();
 
   ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
-                                           resource->resource_id);
+                                           resource->resource_id());
   uint32_t texture_id = lock.texture_id();
 
-  DCHECK_EQ(resource_provider_->GetResourceTextureTarget(resource->resource_id),
-            (GLenum)GL_TEXTURE_2D);
+  DCHECK_EQ(
+      resource_provider_->GetResourceTextureTarget(resource->resource_id()),
+      (GLenum)GL_TEXTURE_2D);
 
   gl->WaitSyncTokenCHROMIUM(mailbox_holder.sync_token.GetConstData());
   uint32_t src_texture_id = gl->CreateAndConsumeTextureCHROMIUM(
       mailbox_holder.texture_target, mailbox_holder.mailbox.name);
   gl->CopySubTextureCHROMIUM(src_texture_id, texture_id, 0, 0, 0, 0,
                              output_plane_resource_size.width(),
                              output_plane_resource_size.height(), false, false,
                              false);
   gl->DeleteTextures(1, &src_texture_id);
 
   // Sync point for use of frame copy.
   gpu::SyncToken sync_token;
   const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
   gl->ShallowFlushCHROMIUM();
   gl->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
 
   // Done with the source video frame texture at this point.
   video_frame->UpdateReleaseSyncToken(&client);
 
   external_resources->mailboxes.push_back(TextureMailbox(
-      resource->mailbox, sync_token, GL_TEXTURE_2D, video_frame->coded_size(),
+      resource->mailbox(), sync_token, GL_TEXTURE_2D, video_frame->coded_size(),
       gfx::GpuMemoryBufferId(), false, false));
 
   external_resources->release_callbacks.push_back(
-      base::Bind(&RecycleResource, AsWeakPtr(), resource->resource_id));
+      base::Bind(&RecycleResource, AsWeakPtr(), resource->resource_id()));
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
   DCHECK(video_frame->HasTextures());
   if (!context_provider_)
     return VideoFrameExternalResources();
 
   VideoFrameExternalResources external_resources;
@@ skipping 42 matching lines @@
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
   if (!updater.get()) {
     // Resource was already deleted.
     return;
   }
 
   const ResourceList::iterator resource_it = std::find_if(
       updater->all_resources_.begin(), updater->all_resources_.end(),
       [resource_id](const PlaneResource& plane_resource) {
-        return plane_resource.resource_id == resource_id;
+        return plane_resource.resource_id() == resource_id;
       });
   if (resource_it == updater->all_resources_.end())
     return;
 
   ContextProvider* context_provider = updater->context_provider_;
   if (context_provider && sync_token.HasData()) {
     context_provider->ContextGL()->WaitSyncTokenCHROMIUM(
         sync_token.GetConstData());
   }
 
   if (lost_resource) {
-    resource_it->ref_count = 0;
+    resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
-  --resource_it->ref_count;
-  DCHECK_GE(resource_it->ref_count, 0);
+  resource_it->remove_ref();
 }
 
-#if DCHECK_IS_ON()
-// static
-void VideoResourceUpdater::MarkOldResource(
-    base::WeakPtr<VideoResourceUpdater> updater,
-    const media::VideoFrame* video_frame_ptr,
-    base::TimeDelta timestamp) {
-  if (!updater)
-    return;
-  const ResourceList::iterator resource_it = std::find_if(
-      updater->all_resources_.begin(), updater->all_resources_.end(),
-      [video_frame_ptr, timestamp](const PlaneResource& plane_resource) {
-        return plane_resource.frame_ptr == video_frame_ptr &&
-               plane_resource.timestamp == timestamp &&
-               plane_resource.plane_index == 0;
-      });
-  if (resource_it == updater->all_resources_.end())
-    return;
-
-  resource_it->destructed = true;
-}
-#endif
-
 }  // namespace cc