// Copyright 2017 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/tiles/checker_image_tracker.h"

#include "base/bind.h"
#include "base/trace_event/trace_event.h"

namespace cc {
namespace {
// The minimum size of an image that we should consider checkering.
size_t kMinImageSizeToCheckerBytes = 512 * 1024;

size_t SafeSizeOfImage(const SkImage* image) {
  base::CheckedNumeric<size_t> checked_size = 4;
  checked_size *= image->width();
  checked_size *= image->height();
  return checked_size.ValueOrDefault(std::numeric_limits<size_t>::max());
}

}  // namespace

CheckerImageTracker::CheckerImageTracker(ImageController* image_controller,
                                         CheckerImageTrackerClient* client,
                                         bool enable_checker_imaging)
    : image_controller_(image_controller),
      client_(client),
      enable_checker_imaging_(enable_checker_imaging),
      weak_factory_(this) {}

CheckerImageTracker::~CheckerImageTracker() {
  // Unlock all images pending decode requests.
  for (auto it : image_id_to_decode_request_id_)
    image_controller_->UnlockImageDecode(it.second);
}

void CheckerImageTracker::FilterImagesForCheckeringForTile(
    std::vector<DrawImage>* images,
    ImageIdFlatSet* checkered_images,
    WhichTree tree) {
  DCHECK(checkered_images->empty());

  auto images_to_checker = std::remove_if(
      images->begin(), images->end(),
      [this, tree, &checkered_images](const DrawImage& draw_image) {
        const sk_sp<const SkImage>& image = draw_image.image();
        DCHECK(image->isLazyGenerated());
        if (ShouldCheckerImage(image, tree)) {
          ScheduleImageDecodeIfNecessary(image);
          checkered_images->insert(image->uniqueID());
          return true;
        }
        return false;
      });
  images->erase(images_to_checker, images->end());
}

const ImageIdFlatSet& CheckerImageTracker::TakeImagesToInvalidateOnSyncTree() {
  DCHECK_EQ(invalidated_images_on_current_sync_tree_.size(), 0u)
      << "Sync tree can not be invalidated more than once";

  invalidated_images_on_current_sync_tree_.swap(images_pending_invalidation_);
  images_pending_invalidation_.clear();
  return invalidated_images_on_current_sync_tree_;
}

void CheckerImageTracker::DidActivateSyncTree() {
  for (auto image_id : invalidated_images_on_current_sync_tree_) {
    auto it = image_id_to_decode_request_id_.find(image_id);
    image_controller_->UnlockImageDecode(it->second);
    image_id_to_decode_request_id_.erase(it);
  }

  invalidated_images_on_current_sync_tree_.clear();
}

void CheckerImageTracker::DidFinishImageDecode(
    ImageId image_id,
    ImageController::ImageDecodeRequestId request_id,
    ImageController::ImageDecodeResult result) {
  TRACE_EVENT_ASYNC_END0("cc", "CheckerImageTracker::DeferImageDecode",
                         image_id);

  DCHECK_NE(result, ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED);
  DCHECK_NE(pending_image_decodes_.count(image_id), 0u);
  pending_image_decodes_.erase(image_id);

  images_decoded_once_.insert(image_id);
  images_pending_invalidation_.insert(image_id);
  client_->NeedsInvalidationForCheckerImagedTiles();
}

bool CheckerImageTracker::ShouldCheckerImage(const sk_sp<const SkImage>& image,
                                             WhichTree tree) const {
  TRACE_EVENT1("cc", "CheckerImageTracker::ShouldCheckerImage", "image_id",
               image->uniqueID());

  if (!enable_checker_imaging_)
    return false;

  // If the image was invalidated on the current sync tree and the tile is
  // for the active tree, continue checkering it on the active tree to ensure
  // the image update is atomic for the frame.
  if (invalidated_images_on_current_sync_tree_.count(image->uniqueID()) != 0 &&
      tree == WhichTree::ACTIVE_TREE) {
    return true;
  }

  // If a decode request is pending for this image, continue checkering it.
  if (pending_image_decodes_.find(image->uniqueID()) !=
      pending_image_decodes_.end()) {
    return true;
  }

  // If the image is pending invalidation, continue checkering it. All tiles
  // for these images will be invalidated on the next pending tree.
  if (images_pending_invalidation_.find(image->uniqueID()) !=
      images_pending_invalidation_.end()) {
    return true;
  }

  // If the image has been decoded once before, don't checker it again.
  if (images_decoded_once_.find(image->uniqueID()) !=
      images_decoded_once_.end()) {
    return false;
  }

  return SafeSizeOfImage(image.get()) >= kMinImageSizeToCheckerBytes;
}

void CheckerImageTracker::ScheduleImageDecodeIfNecessary(
    const sk_sp<const SkImage>& image) {
  ImageId image_id = image->uniqueID();

  // If the image has already been decoded, or a decode request is pending, we
  // don't need to schedule another decode.
  if (images_decoded_once_.count(image_id) != 0 ||
      pending_image_decodes_.count(image_id) != 0) {
    return;
  }

  TRACE_EVENT_ASYNC_BEGIN0("cc", "CheckerImageTracker::DeferImageDecode",
                           image_id);
  DCHECK_EQ(image_id_to_decode_request_id_.count(image_id), 0U);

  image_id_to_decode_request_id_[image_id] =
      image_controller_->QueueImageDecode(
          image, base::Bind(&CheckerImageTracker::DidFinishImageDecode,
                            weak_factory_.GetWeakPtr(), image_id));
  pending_image_decodes_.insert(image_id);
}

}  // namespace cc