cc/layer_tiling_data.cc

   1 // Copyright 2011 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
   6 #include "cc/layer_tiling_data.h"
   7
   8 #include "base/logging.h"
   9
  10 using namespace std;
  11
  12 namespace cc {
  13
  14 scoped_ptr<LayerTilingData> LayerTilingData::create(const gfx::Size& tileSize, BorderTexelOption border)
  15 {
  16     return make_scoped_ptr(new LayerTilingData(tileSize, border));
  17 }
  18
  19 LayerTilingData::LayerTilingData(const gfx::Size& tileSize, BorderTexelOption border)
  20     : m_tilingData(tileSize, gfx::Size(), border == HasBorderTexels)
  21 {
  22     setTileSize(tileSize);
  23 }
  24
  25 LayerTilingData::~LayerTilingData()
  26 {
  27 }
  28
  29 void LayerTilingData::setTileSize(const gfx::Size& size)
  30 {
  31     if (tileSize() == size)
  32         return;
  33
  34     reset();
  35
  36     m_tilingData.SetMaxTextureSize(size);
  37 }
  38
  39 gfx::Size LayerTilingData::tileSize() const
  40 {
  41     return m_tilingData.max_texture_size();
  42 }
  43
  44 void LayerTilingData::setBorderTexelOption(BorderTexelOption borderTexelOption)
  45 {
  46     bool borderTexels = borderTexelOption == HasBorderTexels;
  47     if (hasBorderTexels() == borderTexels)
  48         return;
  49
  50     reset();
  51     m_tilingData.SetHasBorderTexels(borderTexels);
  52 }
  53
  54 const LayerTilingData& LayerTilingData::operator=(const LayerTilingData& tiler)
  55 {
  56     m_tilingData = tiler.m_tilingData;
  57
  58     return *this;
  59 }
  60
  61 void LayerTilingData::addTile(scoped_ptr<Tile> tile, int i, int j)
  62 {
  63     DCHECK(!tileAt(i, j));
  64     tile->moveTo(i, j);
  65     m_tiles.add(make_pair(i, j), tile.Pass());
  66 }
  67
  68 scoped_ptr<LayerTilingData::Tile> LayerTilingData::takeTile(int i, int j)
  69 {
  70     return m_tiles.take_and_erase(make_pair(i, j));
  71 }
  72
  73 LayerTilingData::Tile* LayerTilingData::tileAt(int i, int j) const
  74 {
  75     return m_tiles.get(make_pair(i, j));
  76 }
  77
  78 void LayerTilingData::reset()
  79 {
  80     m_tiles.clear();
  81 }
  82
  83 void LayerTilingData::contentRectToTileIndices(const gfx::Rect& contentRect, int& left, int& top, int& right, int& bottom) const
  84 {
  85     // An empty rect doesn't result in an empty set of tiles, so don't pass an empty rect.
  86     // FIXME: Possibly we should fill a vector of tiles instead,
  87     //        since the normal use of this function is to enumerate some tiles.
  88     DCHECK(!contentRect.IsEmpty());
  89
  90     left = m_tilingData.TileXIndexFromSrcCoord(contentRect.x());
  91     top = m_tilingData.TileYIndexFromSrcCoord(contentRect.y());
  92     right = m_tilingData.TileXIndexFromSrcCoord(contentRect.right() - 1);
  93     bottom = m_tilingData.TileYIndexFromSrcCoord(contentRect.bottom() - 1);
  94 }
  95
  96 gfx::Rect LayerTilingData::tileRect(const Tile* tile) const
  97 {
  98     gfx::Rect tileRect = m_tilingData.TileBoundsWithBorder(tile->i(), tile->j());
  99     tileRect.set_size(tileSize());
 100     return tileRect;
 101 }
 102
 103 Region LayerTilingData::opaqueRegionInContentRect(const gfx::Rect& contentRect) const
 104 {
 105     if (contentRect.IsEmpty())
 106         return Region();
 107
 108     Region opaqueRegion;
 109     int left, top, right, bottom;
 110     contentRectToTileIndices(contentRect, left, top, right, bottom);
 111     for (int j = top; j <= bottom; ++j) {
 112         for (int i = left; i <= right; ++i) {
 113             Tile* tile = tileAt(i, j);
 114             if (!tile)
 115                 continue;
 116
 117             gfx::Rect tileOpaqueRect = gfx::IntersectRects(contentRect, tile->opaqueRect());
 118             opaqueRegion.Union(tileOpaqueRect);
 119         }
 120     }
 121     return opaqueRegion;
 122 }
 123
 124 void LayerTilingData::setBounds(const gfx::Size& size)
 125 {
 126     m_tilingData.SetTotalSize(size);
 127     if (size.IsEmpty()) {
 128         m_tiles.clear();
 129         return;
 130     }
 131
 132     // Any tiles completely outside our new bounds are invalid and should be dropped.
 133     int left, top, right, bottom;
 134     contentRectToTileIndices(gfx::Rect(gfx::Point(), size), left, top, right, bottom);
 135     std::vector<TileMapKey> invalidTileKeys;
 136     for (TileMap::const_iterator it = m_tiles.begin(); it != m_tiles.end(); ++it) {
 137         if (it->first.first > right || it->first.second > bottom)
 138             invalidTileKeys.push_back(it->first);
 139     }
 140     for (size_t i = 0; i < invalidTileKeys.size(); ++i)
 141         m_tiles.erase(invalidTileKeys[i]);
 142 }
 143
 144 gfx::Size LayerTilingData::bounds() const
 145 {
 146     return m_tilingData.total_size();
 147 }
 148
 149 }  // namespace cc