cc/layers/image_layer.cc

   1 // Copyright 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/layers/image_layer.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "cc/resources/image_layer_updater.h"
   9 #include "cc/resources/layer_updater.h"
  10 #include "cc/resources/prioritized_resource.h"
  11 #include "cc/resources/resource_update_queue.h"
  12 #include "cc/trees/layer_tree_host.h"
  13
  14 namespace cc {
  15
  16 scoped_refptr<ImageLayer> ImageLayer::Create() {
  17   return make_scoped_refptr(new ImageLayer());
  18 }
  19
  20 ImageLayer::ImageLayer() : TiledLayer() {}
  21
  22 ImageLayer::~ImageLayer() {}
  23
  24 void ImageLayer::SetBitmap(const SkBitmap& bitmap) {
  25   // SetBitmap() currently gets called whenever there is any
  26   // style change that affects the layer even if that change doesn't
  27   // affect the actual contents of the image (e.g. a CSS animation).
  28   // With this check in place we avoid unecessary texture uploads.
  29   if (bitmap.pixelRef() && bitmap.pixelRef() == bitmap_.pixelRef())
  30     return;
  31
  32   bitmap_ = bitmap;
  33   SetNeedsDisplay();
  34 }
  35
  36 void ImageLayer::SetTexturePriorities(const PriorityCalculator& priority_calc) {
  37   // Update the tile data before creating all the layer's tiles.
  38   UpdateTileSizeAndTilingOption();
  39
  40   TiledLayer::SetTexturePriorities(priority_calc);
  41 }
  42
  43 bool ImageLayer::Update(ResourceUpdateQueue* queue,
  44                         const OcclusionTracker<Layer>* occlusion) {
  45   CreateUpdaterIfNeeded();
  46   if (!updater_->UsingBitmap(bitmap_)) {
  47     updater_->SetBitmap(bitmap_);
  48     UpdateTileSizeAndTilingOption();
  49     InvalidateContentRect(gfx::Rect(content_bounds()));
  50   }
  51   return TiledLayer::Update(queue, occlusion);
  52 }
  53
  54 void ImageLayer::CreateUpdaterIfNeeded() {
  55   if (updater_.get())
  56     return;
  57
  58   updater_ = ImageLayerUpdater::Create();
  59   SetTextureFormat(
  60       layer_tree_host()->GetRendererCapabilities().best_texture_format);
  61 }
  62
  63 LayerUpdater* ImageLayer::Updater() const {
  64   return updater_.get();
  65 }
  66
  67 void ImageLayer::CalculateContentsScale(float ideal_contents_scale,
  68                                         float device_scale_factor,
  69                                         float page_scale_factor,
  70                                         float maximum_animation_contents_scale,
  71                                         bool animating_transform_to_screen,
  72                                         float* contents_scale_x,
  73                                         float* contents_scale_y,
  74                                         gfx::Size* content_bounds) {
  75   *contents_scale_x = ImageContentsScaleX();
  76   *contents_scale_y = ImageContentsScaleY();
  77   *content_bounds = gfx::Size(bitmap_.width(), bitmap_.height());
  78 }
  79
  80 bool ImageLayer::DrawsContent() const {
  81   return !bitmap_.isNull() && TiledLayer::DrawsContent();
  82 }
  83
  84 void ImageLayer::OnOutputSurfaceCreated() {
  85   SetTextureFormat(
  86       layer_tree_host()->GetRendererCapabilities().best_texture_format);
  87   TiledLayer::OnOutputSurfaceCreated();
  88 }
  89
  90 float ImageLayer::ImageContentsScaleX() const {
  91   if (bounds().IsEmpty() || bitmap_.width() == 0)
  92     return 1;
  93   return static_cast<float>(bitmap_.width()) / bounds().width();
  94 }
  95
  96 float ImageLayer::ImageContentsScaleY() const {
  97   if (bounds().IsEmpty() || bitmap_.height() == 0)
  98     return 1;
  99   return static_cast<float>(bitmap_.height()) / bounds().height();
 100 }
 101
 102 }  // namespace cc