ui: Remove unused Layer API.

ui/compositor/layer.cc

 // Copyright (c) 2012 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 49 matching lines @@
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
-      device_scale_factor_(1.0f),
-      texture_x_scale_(1.0f),
-      texture_y_scale_(1.0f) {
+      device_scale_factor_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       fills_bounds_completely_(false),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
-      device_scale_factor_(1.0f),
-      texture_x_scale_(1.0f),
-      texture_y_scale_(1.0f) {
+      device_scale_factor_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::~Layer() {
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   SetAnimator(nullptr);
   if (compositor_)
     compositor_->SetRootLayer(NULL);
@@ skipping 456 matching lines @@
 void Layer::SetTextureFlipped(bool flipped) {
   DCHECK(texture_layer_.get());
   texture_layer_->SetFlipped(flipped);
 }
 
 bool Layer::TextureFlipped() const {
   DCHECK(texture_layer_.get());
   return texture_layer_->flipped();
 }
 
-void Layer::SetTextureAlpha(float alpha) {
-  DCHECK(texture_layer_.get());
-  texture_layer_->SetVertexOpacity(alpha, alpha, alpha, alpha);
-}
-
-void Layer::SetTextureCrop(const gfx::RectF& crop) {
-  DCHECK(texture_layer_.get());
-  texture_crop_ = crop;
-  RecomputeDrawsContentAndUVRect();
-}
-
-void Layer::SetTextureScale(float x_scale, float y_scale) {
-  DCHECK(texture_layer_.get());
-  texture_x_scale_ = x_scale;
-  texture_y_scale_ = y_scale;
-  RecomputeDrawsContentAndUVRect();
-}
-
 void Layer::SetShowSurface(
     const cc::SurfaceId& surface_id,
     const cc::SurfaceLayer::SatisfyCallback& satisfy_callback,
     const cc::SurfaceLayer::RequireCallback& require_callback,
     gfx::Size surface_size,
     float scale,
     gfx::Size frame_size_in_dip) {
   DCHECK(type_ == LAYER_TEXTURED || type_ == LAYER_SOLID_COLOR);
 
   scoped_refptr<cc::SurfaceLayer> new_layer =
@@ skipping 437 matching lines @@
 gfx::Transform Layer::transform() const {
   return cc_layer_->transform();
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(cc_layer_);
   gfx::Size size(bounds_.size());
   if (texture_layer_.get()) {
     size.SetToMin(frame_size_in_dip_);
     gfx::PointF uv_top_left(0.f, 0.f);
-    gfx::PointF uv_bottom_right(1.f, 1.f);
-    if (!texture_crop_.IsEmpty()) {
-      uv_top_left = texture_crop_.origin();
-      uv_top_left.Scale(1.f / frame_size_in_dip_.width(),
-                        1.f / frame_size_in_dip_.height());
-      uv_bottom_right = texture_crop_.bottom_right();
-      uv_bottom_right.Scale(1.f / frame_size_in_dip_.width(),
-                            1.f / frame_size_in_dip_.height());
-    }
-    float x_scale = texture_x_scale_ * static_cast<float>(size.width()) /
-                    frame_size_in_dip_.width();
-    float y_scale = texture_y_scale_ * static_cast<float>(size.height()) /
-                    frame_size_in_dip_.height();
-    uv_top_left.Scale(x_scale, y_scale);
-    uv_bottom_right.Scale(x_scale, y_scale);
+    gfx::PointF uv_bottom_right(
+      static_cast<float>(size.width()) / frame_size_in_dip_.width(),
+      static_cast<float>(size.height()) / frame_size_in_dip_.height());
     texture_layer_->SetUV(uv_top_left, uv_bottom_right);
   } else if (surface_layer_.get()) {
     size.SetToMin(frame_size_in_dip_);
   }
   cc_layer_->SetBounds(size);
 }
 
 void Layer::RecomputePosition() {
   cc_layer_->SetPosition(gfx::PointF(bounds_.origin()) +
                          subpixel_position_offset_);
@@ skipping 20 matching lines @@
   if (animator_) {
     animator_->ResetCompositor(compositor);
     animator_->RemoveFromCollection(collection);
   }
 
   for (auto* child : children_)
     child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui