// 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/layers/nine_patch_generator.h"

#include "base/trace_event/traced_value.h"
#include "cc/base/math_util.h"
#include "cc/trees/layer_tree_impl.h"
#include "components/viz/client/client_resource_provider.h"
#include "components/viz/common/quads/compositor_render_pass.h"
#include "components/viz/common/quads/texture_draw_quad.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/rect_f.h"

namespace cc {

namespace {

// Maximum number of patches that can be produced for one NinePatchLayer.
const int kMaxOcclusionPatches = 12;
const int kMaxPatches = 9;

gfx::Rect BoundsToRect(int x1, int y1, int x2, int y2) {
  return gfx::Rect(x1, y1, x2 - x1, y2 - y1);
}

gfx::RectF NormalizedRect(const gfx::Rect& rect,
                          float total_width,
                          float total_height) {
  return gfx::RectF(rect.x() / total_width, rect.y() / total_height,
                    rect.width() / total_width, rect.height() / total_height);
}

}  // namespace

NinePatchGenerator::Patch::Patch(const gfx::Rect& image_rect,
                                 const gfx::Size& total_image_bounds,
                                 const gfx::Rect& output_rect)
    : image_rect(image_rect),
      normalized_image_rect(NormalizedRect(image_rect,
                                           total_image_bounds.width(),
                                           total_image_bounds.height())),
      output_rect(output_rect) {}

NinePatchGenerator::NinePatchGenerator()
    : fill_center_(false), nearest_neighbor_(false) {}

bool NinePatchGenerator::SetLayout(const gfx::Size& image_bounds,
                                   const gfx::Size& output_bounds,
                                   const gfx::Rect& aperture,
                                   const gfx::Rect& border,
                                   const gfx::Rect& output_occlusion,
                                   bool fill_center,
                                   bool nearest_neighbor) {
  if (image_bounds_ == image_bounds && output_bounds_ == output_bounds &&
      image_aperture_ == aperture && border_ == border &&
      fill_center_ == fill_center && output_occlusion_ == output_occlusion &&
      nearest_neighbor_ == nearest_neighbor)
    return false;

  image_bounds_ = image_bounds;
  output_bounds_ = output_bounds;
  image_aperture_ = aperture;
  border_ = border;
  fill_center_ = fill_center;
  output_occlusion_ = output_occlusion;
  nearest_neighbor_ = nearest_neighbor;

  return true;
}

void NinePatchGenerator::CheckGeometryLimitations() {
  // |border| is in layer space.  It cannot exceed the bounds of the layer.
  DCHECK_GE(output_bounds_.width(), border_.width());
  DCHECK_GE(output_bounds_.height(), border_.height());

  // Sanity Check on |border|
  DCHECK_LE(border_.x(), border_.width());
  DCHECK_LE(border_.y(), border_.height());
  DCHECK_GE(border_.x(), 0);
  DCHECK_GE(border_.y(), 0);

  // |aperture| is in image space.  It cannot exceed the bounds of the bitmap.
  DCHECK(!image_aperture_.size().IsEmpty());
  DCHECK(gfx::Rect(image_bounds_).Contains(image_aperture_))
      << "image_bounds_ " << gfx::Rect(image_bounds_).ToString()
      << " image_aperture_ " << image_aperture_.ToString();

  // Sanity check on |output_occlusion_|. It should always be within the
  // border.
  gfx::Rect border_rect(border_.x(), border_.y(),
                        output_bounds_.width() - border_.width(),
                        output_bounds_.height() - border_.height());
  DCHECK(output_occlusion_.IsEmpty() || output_occlusion_.Contains(border_rect))
      << "border_rect " << border_rect.ToString() << " output_occlusion_ "
      << output_occlusion_.ToString();
}

std::vector<NinePatchGenerator::Patch>
NinePatchGenerator::ComputeQuadsWithoutOcclusion() const {
  float image_width = image_bounds_.width();
  float image_height = image_bounds_.height();
  float output_width = output_bounds_.width();
  float output_height = output_bounds_.height();
  gfx::RectF output_aperture(border_.x(), border_.y(),
                             output_width - border_.width(),
                             output_height - border_.height());

  if (fill_center_) {
    bool match_horizontally =
        output_aperture.x() == image_aperture_.x() &&
        output_aperture.width() == image_aperture_.width() &&
        output_width == image_width;
    bool match_vertically =
        output_aperture.y() == image_aperture_.y() &&
        output_aperture.height() == image_aperture_.height() &&
        output_height == image_height;

    if (match_horizontally) {
      if (match_vertically) {
        // Only need 1 patch.
        return {Patch(gfx::Rect(image_bounds_), image_bounds_,
                      gfx::Rect(image_bounds_))};
      }

      // Only need 3 vertical patches.
      return {Patch(BoundsToRect(0, 0, image_width, image_aperture_.y()),
                    image_bounds_,
                    BoundsToRect(0, 0, image_width, output_aperture.y())),
              Patch(BoundsToRect(0, image_aperture_.y(), image_width,
                                 image_aperture_.bottom()),
                    image_bounds_,
                    BoundsToRect(0, output_aperture.y(), image_width,
                                 output_aperture.bottom())),
              Patch(BoundsToRect(0, image_aperture_.bottom(), image_width,
                                 image_height),
                    image_bounds_,
                    BoundsToRect(0, output_aperture.bottom(), image_width,
                                 output_height))};
    }

    if (match_vertically) {
      // Only need 3 horizontal patches.
      return {Patch(BoundsToRect(0, 0, image_aperture_.x(), image_height),
                    image_bounds_,
                    BoundsToRect(0, 0, output_aperture.x(), image_height)),
              Patch(BoundsToRect(image_aperture_.x(), 0,
                                 image_aperture_.right(), image_height),
                    image_bounds_,
                    BoundsToRect(output_aperture.x(), 0,
                                 output_aperture.right(), image_height)),
              Patch(BoundsToRect(image_aperture_.right(), 0, image_width,
                                 image_height),
                    image_bounds_,
                    BoundsToRect(output_aperture.right(), 0, output_width,
                                 image_height))};
    }
  }

  std::vector<Patch> patches;
  patches.reserve(kMaxPatches);

  // Top-left.
  patches.push_back(
      Patch(BoundsToRect(0, 0, image_aperture_.x(), image_aperture_.y()),
            image_bounds_,
            BoundsToRect(0, 0, output_aperture.x(), output_aperture.y())));

  // Top-right.
  patches.push_back(Patch(BoundsToRect(image_aperture_.right(), 0, image_width,
                                       image_aperture_.y()),
                          image_bounds_,
                          BoundsToRect(output_aperture.right(), 0, output_width,
                                       output_aperture.y())));

  // Bottom-left.
  patches.push_back(Patch(BoundsToRect(0, image_aperture_.bottom(),
                                       image_aperture_.x(), image_height),
                          image_bounds_,
                          BoundsToRect(0, output_aperture.bottom(),
                                       output_aperture.x(), output_height)));

  // Bottom-right.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.right(), image_aperture_.bottom(),
                         image_width, image_height),
            image_bounds_,
            BoundsToRect(output_aperture.right(), output_aperture.bottom(),
                         output_width, output_height)));

  // Top.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.x(), 0, image_aperture_.right(),
                         image_aperture_.y()),
            image_bounds_,
            BoundsToRect(output_aperture.x(), 0, output_aperture.right(),
                         output_aperture.y())));

  // Left.
  patches.push_back(
      Patch(BoundsToRect(0, image_aperture_.y(), image_aperture_.x(),
                         image_aperture_.bottom()),
            image_bounds_,
            BoundsToRect(0, output_aperture.y(), output_aperture.x(),
                         output_aperture.bottom())));

  // Right.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.right(), image_aperture_.y(),
                         image_width, image_aperture_.bottom()),
            image_bounds_,
            BoundsToRect(output_aperture.right(), output_aperture.y(),
                         output_width, output_aperture.bottom())));

  // Bottom.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.x(), image_aperture_.bottom(),
                         image_aperture_.right(), image_height),
            image_bounds_,
            BoundsToRect(output_aperture.x(), output_aperture.bottom(),
                         output_aperture.right(), output_height)));

  // Center.
  if (fill_center_) {
    patches.push_back(
        Patch(BoundsToRect(image_aperture_.x(), image_aperture_.y(),
                           image_aperture_.right(), image_aperture_.bottom()),
              image_bounds_,
              BoundsToRect(output_aperture.x(), output_aperture.y(),
                           output_aperture.right(), output_aperture.bottom())));
  }

  return patches;
}

std::vector<NinePatchGenerator::Patch>
NinePatchGenerator::ComputeQuadsWithOcclusion() const {
  float image_width = image_bounds_.width();
  float image_height = image_bounds_.height();

  float output_width = output_bounds_.width();
  float output_height = output_bounds_.height();

  float layer_border_right = border_.width() - border_.x();
  float layer_border_bottom = border_.height() - border_.y();

  float image_aperture_right = image_width - image_aperture_.right();
  float image_aperture_bottom = image_height - image_aperture_.bottom();

  float output_occlusion_right = output_width - output_occlusion_.right();
  float output_occlusion_bottom = output_height - output_occlusion_.bottom();

  gfx::RectF image_occlusion(BoundsToRect(
      border_.x() == 0
          ? 0
          : (output_occlusion_.x() * image_aperture_.x() / border_.x()),
      border_.y() == 0
          ? 0
          : (output_occlusion_.y() * image_aperture_.y() / border_.y()),
      image_width - (layer_border_right == 0
                         ? 0
                         : output_occlusion_right * image_aperture_right /
                               layer_border_right),
      image_height - (layer_border_bottom == 0
                          ? 0
                          : output_occlusion_bottom * image_aperture_bottom /
                                layer_border_bottom)));
  gfx::RectF output_aperture(border_.x(), border_.y(),
                             output_width - border_.width(),
                             output_height - border_.height());

  std::vector<Patch> patches;
  patches.reserve(kMaxOcclusionPatches);

  // Top-left-left.
  patches.push_back(
      Patch(BoundsToRect(0, 0, image_occlusion.x(), image_aperture_.y()),
            image_bounds_,
            BoundsToRect(0, 0, output_occlusion_.x(), output_aperture.y())));

  // Top-left-right.
  patches.push_back(
      Patch(BoundsToRect(image_occlusion.x(), 0, image_aperture_.x(),
                         image_occlusion.y()),
            image_bounds_,
            BoundsToRect(output_occlusion_.x(), 0, output_aperture.x(),
                         output_occlusion_.y())));

  // Top-center.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.x(), 0, image_aperture_.right(),
                         image_occlusion.y()),
            image_bounds_,
            BoundsToRect(output_aperture.x(), 0, output_aperture.right(),
                         output_occlusion_.y())));

  // Top-right-left.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.right(), 0, image_occlusion.right(),
                         image_occlusion.y()),
            image_bounds_,
            BoundsToRect(output_aperture.right(), 0, output_occlusion_.right(),
                         output_occlusion_.y())));

  // Top-right-right.
  patches.push_back(Patch(BoundsToRect(image_occlusion.right(), 0, image_width,
                                       image_aperture_.y()),
                          image_bounds_,
                          BoundsToRect(output_occlusion_.right(), 0,
                                       output_width, output_aperture.y())));

  // Left-center.
  patches.push_back(
      Patch(BoundsToRect(0, image_aperture_.y(), image_occlusion.x(),
                         image_aperture_.bottom()),
            image_bounds_,
            BoundsToRect(0, output_aperture.y(), output_occlusion_.x(),
                         output_aperture.bottom())));

  // Right-center.
  patches.push_back(
      Patch(BoundsToRect(image_occlusion.right(), image_aperture_.y(),
                         image_width, image_aperture_.bottom()),
            image_bounds_,
            BoundsToRect(output_occlusion_.right(), output_aperture.y(),
                         output_width, output_aperture.bottom())));

  // Bottom-left-left.
  patches.push_back(Patch(BoundsToRect(0, image_aperture_.bottom(),
                                       image_occlusion.x(), image_height),
                          image_bounds_,
                          BoundsToRect(0, output_aperture.bottom(),
                                       output_occlusion_.x(), output_height)));

  // Bottom-left-right.
  patches.push_back(
      Patch(BoundsToRect(image_occlusion.x(), image_occlusion.bottom(),
                         image_aperture_.x(), image_height),
            image_bounds_,
            BoundsToRect(output_occlusion_.x(), output_occlusion_.bottom(),
                         output_aperture.x(), output_height)));

  // Bottom-center.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.x(), image_occlusion.bottom(),
                         image_aperture_.right(), image_height),
            image_bounds_,
            BoundsToRect(output_aperture.x(), output_occlusion_.bottom(),
                         output_aperture.right(), output_height)));

  // Bottom-right-left.
  patches.push_back(
      Patch(BoundsToRect(image_aperture_.right(), image_occlusion.bottom(),
                         image_occlusion.right(), image_height),
            image_bounds_,
            BoundsToRect(output_aperture.right(), output_occlusion_.bottom(),
                         output_occlusion_.right(), output_height)));

  // Bottom-right-right.
  patches.push_back(
      Patch(BoundsToRect(image_occlusion.right(), image_aperture_.bottom(),
                         image_width, image_height),
            image_bounds_,
            BoundsToRect(output_occlusion_.right(), output_aperture.bottom(),
                         output_width, output_height)));

  return patches;
}

std::vector<NinePatchGenerator::Patch> NinePatchGenerator::GeneratePatches()
    const {
  DCHECK(!output_bounds_.IsEmpty());

  std::vector<Patch> patches;

  if (output_occlusion_.IsEmpty() || fill_center_)
    patches = ComputeQuadsWithoutOcclusion();
  else
    patches = ComputeQuadsWithOcclusion();

  return patches;
}

void NinePatchGenerator::AppendQuadsForCc(
    LayerImpl* layer_impl,
    UIResourceId ui_resource_id,
    viz::CompositorRenderPass* render_pass,
    viz::SharedQuadState* shared_quad_state,
    const std::vector<Patch>& patches,
    const gfx::Vector2d& offset) {
  if (!ui_resource_id) {
    return;
  }

  viz::ResourceId resource =
      layer_impl->layer_tree_impl()->ResourceIdForUIResource(ui_resource_id);
  if (!resource) {
    return;
  }

  const bool opaque =
      layer_impl->layer_tree_impl()->IsUIResourceOpaque(ui_resource_id);
  AppendQuads(
      resource, opaque,
      [layer_impl](const gfx::Rect& rect) {
        return layer_impl->draw_properties()
            .occlusion_in_content_space.GetUnoccludedContentRect(rect);
      },
      layer_impl->layer_tree_impl()->resource_provider(), render_pass,
      shared_quad_state, patches, offset);
}

void NinePatchGenerator::AppendQuads(
    viz::ResourceId resource,
    bool opaque,
    base::FunctionRef<gfx::Rect(const gfx::Rect&)> clip_visible_rect,
    viz::ClientResourceProvider* client_resource_provider,
    viz::CompositorRenderPass* render_pass,
    viz::SharedQuadState* shared_quad_state,
    const std::vector<Patch>& patches,
    const gfx::Vector2d& offset) {
  if (!resource) {
    return;
  }
#if DCHECK_IS_ON()
  client_resource_provider->ValidateResource(resource);
#endif

  for (const auto& patch : patches) {
    gfx::Rect output_rect = patch.output_rect + offset;
    gfx::Rect visible_rect = clip_visible_rect(output_rect);
    bool needs_blending = !opaque;
    if (!visible_rect.IsEmpty()) {
      gfx::RectF image_rect = patch.normalized_image_rect;
      auto* quad = render_pass->CreateAndAppendDrawQuad<viz::TextureDrawQuad>();
      quad->SetNew(shared_quad_state, output_rect, visible_rect, needs_blending,
                   resource, image_rect.origin(), image_rect.bottom_right(),
                   SkColors::kTransparent, nearest_neighbor_,
                   /*secure_output=*/false, gfx::ProtectedVideoType::kClear);
    }
  }
}

void NinePatchGenerator::AsValueInto(
    base::trace_event::TracedValue* state) const {
  MathUtil::AddToTracedValue("ImageAperture", image_aperture_, state);
  MathUtil::AddToTracedValue("ImageBounds", image_bounds_, state);
  MathUtil::AddToTracedValue("Border", border_, state);
  state->SetBoolean("FillCenter", fill_center_);
  MathUtil::AddToTracedValue("OutputOcclusion", output_occlusion_, state);
}

}  // namespace cc