[M108 Migration][VD] Avoid pending frame counter becoming negative

[platform/framework/web/chromium-efl.git] / cc / tiles / decoded_image_tracker.cc

diff --git a/cc/tiles/decoded_image_tracker.cc b/cc/tiles/decoded_image_tracker.cc
index 9f717c9..0670409 100644 (file)
--- a/cc/tiles/decoded_image_tracker.cc
+++ b/cc/tiles/decoded_image_tracker.cc
@@ -1,8 +1,9 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/decoded_image_tracker.h"
+#include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 
 namespace cc {
@@ -27,8 +28,7 @@ DecodedImageTracker::DecodedImageTracker(
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : image_controller_(controller),
       task_runner_(std::move(task_runner)),
-      now_fn_(base::Bind(&base::TimeTicks::Now)),
-      weak_ptr_factory_(this) {
+      tick_clock_(base::DefaultTickClock::GetInstance()) {
   DCHECK(image_controller_);
 }
 
@@ -38,8 +38,8 @@ DecodedImageTracker::~DecodedImageTracker() {
 
 void DecodedImageTracker::QueueImageDecode(
     const PaintImage& image,
-    const gfx::ColorSpace& target_color_space,
-    const base::Callback<void(bool)>& callback) {
+    const TargetColorParams& target_color_params,
+    base::OnceCallback<void(bool)> callback) {
   size_t frame_index = PaintImage::kDefaultFrameIndex;
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "DecodedImageTracker::QueueImageDecode", "frame_key",
@@ -48,12 +48,13 @@ void DecodedImageTracker::QueueImageDecode(
   // Queue the decode in the image controller, but switch out the callback for
   // our own.
   auto image_bounds = SkIRect::MakeWH(image.width(), image.height());
-  DrawImage draw_image(image, image_bounds, kNone_SkFilterQuality,
-                       SkMatrix::I(), frame_index, target_color_space);
+  DrawImage draw_image(image, false, image_bounds,
+                       PaintFlags::FilterQuality::kNone, SkM44(), frame_index,
+                       target_color_params);
   image_controller_->QueueImageDecode(
-      draw_image,
-      base::Bind(&DecodedImageTracker::ImageDecodeFinished,
-                 base::Unretained(this), callback, image.stable_id()));
+      draw_image, base::BindOnce(&DecodedImageTracker::ImageDecodeFinished,
+                                 base::Unretained(this), std::move(callback),
+                                 image.stable_id()));
 }
 
 void DecodedImageTracker::UnlockAllImages() {
@@ -67,7 +68,7 @@ void DecodedImageTracker::OnImagesUsedInDraw(
 }
 
 void DecodedImageTracker::ImageDecodeFinished(
-    const base::Callback<void(bool)>& callback,
+    base::OnceCallback<void(bool)> callback,
     PaintImage::Id image_id,
     ImageController::ImageDecodeRequestId request_id,
     ImageController::ImageDecodeResult result) {
@@ -79,13 +80,14 @@ void DecodedImageTracker::ImageDecodeFinished(
     // decode.
     locked_images_.erase(image_id);
     locked_images_.emplace(
-        image_id, std::make_unique<ImageLock>(this, request_id, now_fn_.Run()));
+        image_id,
+        std::make_unique<ImageLock>(this, request_id, tick_clock_->NowTicks()));
     EnqueueTimeout();
   }
   bool decode_succeeded =
       result == ImageController::ImageDecodeResult::SUCCESS ||
       result == ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED;
-  callback.Run(decode_succeeded);
+  std::move(callback).Run(decode_succeeded);
 }
 
 void DecodedImageTracker::OnTimeoutImages() {
@@ -93,8 +95,8 @@ void DecodedImageTracker::OnTimeoutImages() {
   if (locked_images_.size() == 0)
     return;
 
-  auto now = now_fn_.Run();
-  auto timeout = base::TimeDelta::FromMilliseconds(kTimeoutDurationMs);
+  auto now = tick_clock_->NowTicks();
+  auto timeout = base::Milliseconds(kTimeoutDurationMs);
   for (auto it = locked_images_.begin(); it != locked_images_.end();) {
     auto& image = it->second;
     if (now - image->lock_time() < timeout) {
@@ -116,9 +118,9 @@ void DecodedImageTracker::EnqueueTimeout() {
   timeout_pending_ = true;
   task_runner_->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&DecodedImageTracker::OnTimeoutImages,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kTimeoutDurationMs));
+      base::BindOnce(&DecodedImageTracker::OnTimeoutImages,
+                     weak_ptr_factory_.GetWeakPtr()),
+      base::Milliseconds(kTimeoutDurationMs));
 }
 
 }  // namespace cc