cc/layer_impl.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 #include "cc/layer_impl.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/stringprintf.h"
   9 #include "cc/debug_border_draw_quad.h"
  10 #include "cc/debug_colors.h"
  11 #include "cc/layer_sorter.h"
  12 #include "cc/layer_tree_host_impl.h"
  13 #include "cc/math_util.h"
  14 #include "cc/proxy.h"
  15 #include "cc/quad_sink.h"
  16 #include "cc/scrollbar_animation_controller.h"
  17 #include "ui/gfx/point_conversions.h"
  18 #include "ui/gfx/rect_conversions.h"
  19
  20 namespace cc {
  21
  22 LayerImpl::LayerImpl(int id)
  23     : m_parent(0)
  24     , m_maskLayerId(-1)
  25     , m_replicaLayerId(-1)
  26     , m_layerId(id)
  27     , m_layerTreeHostImpl(0)
  28     , m_anchorPoint(0.5, 0.5)
  29     , m_anchorPointZ(0)
  30     , m_contentsScaleX(1.0)
  31     , m_contentsScaleY(1.0)
  32     , m_scrollable(false)
  33     , m_shouldScrollOnMainThread(false)
  34     , m_haveWheelEventHandlers(false)
  35     , m_backgroundColor(0)
  36     , m_doubleSided(true)
  37     , m_layerPropertyChanged(false)
  38     , m_layerSurfacePropertyChanged(false)
  39     , m_masksToBounds(false)
  40     , m_contentsOpaque(false)
  41     , m_opacity(1.0)
  42     , m_preserves3D(false)
  43     , m_useParentBackfaceVisibility(false)
  44     , m_drawCheckerboardForMissingTiles(false)
  45     , m_useLCDText(false)
  46     , m_drawsContent(false)
  47     , m_forceRenderSurface(false)
  48     , m_isContainerForFixedPositionLayers(false)
  49     , m_fixedToContainerLayer(false)
  50     , m_drawDepth(0)
  51 #ifndef NDEBUG
  52     , m_betweenWillDrawAndDidDraw(false)
  53 #endif
  54     , m_layerAnimationController(LayerAnimationController::create(this))
  55 {
  56     DCHECK(m_layerId > 0);
  57 }
  58
  59 LayerImpl::~LayerImpl()
  60 {
  61 #ifndef NDEBUG
  62     DCHECK(!m_betweenWillDrawAndDidDraw);
  63 #endif
  64 }
  65
  66 void LayerImpl::addChild(scoped_ptr<LayerImpl> child)
  67 {
  68     child->setParent(this);
  69     m_children.append(child.Pass());
  70 }
  71
  72 void LayerImpl::removeFromParent()
  73 {
  74     if (!m_parent)
  75         return;
  76
  77     LayerImpl* parent = m_parent;
  78     m_parent = 0;
  79
  80     for (size_t i = 0; i < parent->m_children.size(); ++i) {
  81         if (parent->m_children[i] == this) {
  82             parent->m_children.remove(i);
  83             return;
  84         }
  85     }
  86 }
  87
  88 void LayerImpl::removeAllChildren()
  89 {
  90     while (m_children.size())
  91         m_children[0]->removeFromParent();
  92 }
  93
  94 void LayerImpl::clearChildList()
  95 {
  96     m_children.clear();
  97 }
  98
  99 void LayerImpl::createRenderSurface()
 100 {
 101     DCHECK(!m_drawProperties.render_surface);
 102     m_drawProperties.render_surface = make_scoped_ptr(new RenderSurfaceImpl(this));
 103     m_drawProperties.render_target = this;
 104 }
 105
 106 int LayerImpl::descendantsDrawContent()
 107 {
 108     int result = 0;
 109     for (size_t i = 0; i < m_children.size(); ++i) {
 110         if (m_children[i]->drawsContent())
 111             ++result;
 112         result += m_children[i]->descendantsDrawContent();
 113         if (result > 1)
 114             return result;
 115     }
 116     return result;
 117 }
 118
 119 scoped_ptr<SharedQuadState> LayerImpl::createSharedQuadState() const
 120 {
 121   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
 122   state->SetAll(m_drawProperties.target_space_transform,
 123                 m_drawProperties.visible_content_rect,
 124                 m_drawProperties.drawable_content_rect,
 125                 m_drawProperties.clip_rect,
 126                 m_drawProperties.is_clipped,
 127                 m_drawProperties.opacity);
 128   return state.Pass();
 129 }
 130
 131 void LayerImpl::willDraw(ResourceProvider*)
 132 {
 133 #ifndef NDEBUG
 134     // willDraw/didDraw must be matched.
 135     DCHECK(!m_betweenWillDrawAndDidDraw);
 136     m_betweenWillDrawAndDidDraw = true;
 137 #endif
 138 }
 139
 140 void LayerImpl::didDraw(ResourceProvider*)
 141 {
 142 #ifndef NDEBUG
 143     DCHECK(m_betweenWillDrawAndDidDraw);
 144     m_betweenWillDrawAndDidDraw = false;
 145 #endif
 146 }
 147
 148 bool LayerImpl::showDebugBorders() const
 149 {
 150     if (!m_layerTreeHostImpl)
 151         return false;
 152     return m_layerTreeHostImpl->debugState().showDebugBorders;
 153 }
 154
 155 void LayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
 156 {
 157     if (m_drawsContent) {
 158         *color = DebugColors::ContentLayerBorderColor();
 159         *width = DebugColors::ContentLayerBorderWidth(m_layerTreeHostImpl);
 160         return;
 161     }
 162
 163     if (m_masksToBounds) {
 164         *color = DebugColors::MaskingLayerBorderColor();
 165         *width = DebugColors::MaskingLayerBorderWidth(m_layerTreeHostImpl);
 166         return;
 167     }
 168
 169     *color = DebugColors::ContainerLayerBorderColor();
 170     *width = DebugColors::ContainerLayerBorderWidth(m_layerTreeHostImpl);
 171 }
 172
 173 void LayerImpl::appendDebugBorderQuad(QuadSink& quadList, const SharedQuadState* sharedQuadState, AppendQuadsData& appendQuadsData) const
 174 {
 175     if (!showDebugBorders())
 176         return;
 177
 178     SkColor color;
 179     float width;
 180     getDebugBorderProperties(&color, &width);
 181
 182     gfx::Rect contentRect(gfx::Point(), contentBounds());
 183     scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
 184     debugBorderQuad->SetNew(sharedQuadState, contentRect, color, width);
 185     quadList.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
 186 }
 187
 188 bool LayerImpl::hasContributingDelegatedRenderPasses() const
 189 {
 190     return false;
 191 }
 192
 193 RenderPass::Id LayerImpl::firstContributingRenderPassId() const
 194 {
 195     return RenderPass::Id(0, 0);
 196 }
 197
 198 RenderPass::Id LayerImpl::nextContributingRenderPassId(RenderPass::Id) const
 199 {
 200     return RenderPass::Id(0, 0);
 201 }
 202
 203 ResourceProvider::ResourceId LayerImpl::contentsResourceId() const
 204 {
 205     NOTREACHED();
 206     return 0;
 207 }
 208
 209 gfx::Vector2dF LayerImpl::scrollBy(const gfx::Vector2dF& scroll)
 210 {
 211     gfx::Vector2dF minDelta = -m_scrollOffset;
 212     gfx::Vector2dF maxDelta = m_maxScrollOffset - m_scrollOffset;
 213     // Clamp newDelta so that position + delta stays within scroll bounds.
 214     gfx::Vector2dF newDelta = (m_scrollDelta + scroll);
 215     newDelta.ClampToMin(minDelta);
 216     newDelta.ClampToMax(maxDelta);
 217     gfx::Vector2dF unscrolled = m_scrollDelta + scroll - newDelta;
 218
 219     if (m_scrollDelta == newDelta)
 220         return unscrolled;
 221
 222     m_scrollDelta = newDelta;
 223     if (m_scrollbarAnimationController)
 224         m_scrollbarAnimationController->updateScrollOffset(this);
 225     noteLayerPropertyChangedForSubtree();
 226
 227     return unscrolled;
 228 }
 229
 230 InputHandlerClient::ScrollStatus LayerImpl::tryScroll(const gfx::PointF& screenSpacePoint, InputHandlerClient::ScrollInputType type) const
 231 {
 232     if (shouldScrollOnMainThread()) {
 233         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed shouldScrollOnMainThread");
 234         return InputHandlerClient::ScrollOnMainThread;
 235     }
 236
 237     if (!screenSpaceTransform().IsInvertible()) {
 238         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored nonInvertibleTransform");
 239         return InputHandlerClient::ScrollIgnored;
 240     }
 241
 242     if (!nonFastScrollableRegion().IsEmpty()) {
 243         bool clipped = false;
 244         gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(MathUtil::inverse(screenSpaceTransform()), screenSpacePoint, clipped);
 245         gfx::PointF hitTestPointInLayerSpace = gfx::ScalePoint(hitTestPointInContentSpace, 1 / contentsScaleX(), 1 / contentsScaleY());
 246         if (!clipped && nonFastScrollableRegion().Contains(gfx::ToRoundedPoint(hitTestPointInLayerSpace))) {
 247             TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed nonFastScrollableRegion");
 248             return InputHandlerClient::ScrollOnMainThread;
 249         }
 250     }
 251
 252     if (type == InputHandlerClient::Wheel && haveWheelEventHandlers()) {
 253         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed wheelEventHandlers");
 254         return InputHandlerClient::ScrollOnMainThread;
 255     }
 256
 257     if (!scrollable()) {
 258         TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
 259         return InputHandlerClient::ScrollIgnored;
 260     }
 261
 262     return InputHandlerClient::ScrollStarted;
 263 }
 264
 265 bool LayerImpl::drawCheckerboardForMissingTiles() const
 266 {
 267     return m_drawCheckerboardForMissingTiles && !m_layerTreeHostImpl->settings().backgroundColorInsteadOfCheckerboard;
 268 }
 269
 270 gfx::Rect LayerImpl::layerRectToContentRect(const gfx::RectF& layerRect) const
 271 {
 272     gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
 273     // Intersect with content rect to avoid the extra pixel because for some
 274     // values x and y, ceil((x / y) * y) may be x + 1.
 275     contentRect.Intersect(gfx::Rect(gfx::Point(), contentBounds()));
 276     return gfx::ToEnclosingRect(contentRect);
 277 }
 278
 279 std::string LayerImpl::indentString(int indent)
 280 {
 281     std::string str;
 282     for (int i = 0; i != indent; ++i)
 283         str.append("  ");
 284     return str;
 285 }
 286
 287 void LayerImpl::dumpLayerProperties(std::string* str, int indent) const
 288 {
 289     std::string indentStr = indentString(indent);
 290     str->append(indentStr);
 291     base::StringAppendF(str, "layer ID: %d\n", m_layerId);
 292
 293     str->append(indentStr);
 294     base::StringAppendF(str, "bounds: %d, %d\n", bounds().width(), bounds().height());
 295
 296     if (m_drawProperties.render_target) {
 297         str->append(indentStr);
 298         base::StringAppendF(str, "renderTarget: %d\n", m_drawProperties.render_target->m_layerId);
 299     }
 300
 301     str->append(indentStr);
 302     base::StringAppendF(str, "position: %f, %f\n", m_position.x(), m_position.y());
 303
 304     str->append(indentStr);
 305     base::StringAppendF(str, "contentsOpaque: %d\n", m_contentsOpaque);
 306
 307     str->append(indentStr);
 308     const gfx::Transform& transform = m_drawProperties.target_space_transform;
 309     base::StringAppendF(str, "drawTransform: %f, %f, %f, %f  //  %f, %f, %f, %f  //  %f, %f, %f, %f  //  %f, %f, %f, %f\n",
 310         transform.matrix().getDouble(0, 0), transform.matrix().getDouble(0, 1), transform.matrix().getDouble(0, 2), transform.matrix().getDouble(0, 3),
 311         transform.matrix().getDouble(1, 0), transform.matrix().getDouble(1, 1), transform.matrix().getDouble(1, 2), transform.matrix().getDouble(1, 3),
 312         transform.matrix().getDouble(2, 0), transform.matrix().getDouble(2, 1), transform.matrix().getDouble(2, 2), transform.matrix().getDouble(2, 3),
 313         transform.matrix().getDouble(3, 0), transform.matrix().getDouble(3, 1), transform.matrix().getDouble(3, 2), transform.matrix().getDouble(3, 3));
 314
 315     str->append(indentStr);
 316     base::StringAppendF(str, "drawsContent: %s\n", m_drawsContent ? "yes" : "no");
 317 }
 318
 319 void sortLayers(std::vector<LayerImpl*>::iterator first, std::vector<LayerImpl*>::iterator end, LayerSorter* layerSorter)
 320 {
 321     TRACE_EVENT0("cc", "LayerImpl::sortLayers");
 322     layerSorter->sort(first, end);
 323 }
 324
 325 std::string LayerImpl::layerTreeAsText() const
 326 {
 327     std::string str;
 328     dumpLayer(&str, 0);
 329     return str;
 330 }
 331
 332 void LayerImpl::dumpLayer(std::string* str, int indent) const
 333 {
 334     str->append(indentString(indent));
 335     base::StringAppendF(str, "%s(%s)\n", layerTypeAsString(), m_debugName.data());
 336     dumpLayerProperties(str, indent+2);
 337     if (m_replicaLayer) {
 338         str->append(indentString(indent+2));
 339         str->append("Replica:\n");
 340         m_replicaLayer->dumpLayer(str, indent+3);
 341     }
 342     if (m_maskLayer) {
 343         str->append(indentString(indent+2));
 344         str->append("Mask:\n");
 345         m_maskLayer->dumpLayer(str, indent+3);
 346     }
 347     for (size_t i = 0; i < m_children.size(); ++i)
 348         m_children[i]->dumpLayer(str, indent+1);
 349 }
 350
 351 void LayerImpl::setStackingOrderChanged(bool stackingOrderChanged)
 352 {
 353     // We don't need to store this flag; we only need to track that the change occurred.
 354     if (stackingOrderChanged)
 355         noteLayerPropertyChangedForSubtree();
 356 }
 357
 358 bool LayerImpl::layerSurfacePropertyChanged() const
 359 {
 360     if (m_layerSurfacePropertyChanged)
 361         return true;
 362
 363     // If this layer's surface property hasn't changed, we want to see if
 364     // some layer above us has changed this property. This is done for the
 365     // case when such parent layer does not draw content, and therefore will
 366     // not be traversed by the damage tracker. We need to make sure that
 367     // property change on such layer will be caught by its descendants.
 368     LayerImpl* current = this->m_parent;
 369     while (current && !current->m_drawProperties.render_surface) {
 370         if (current->m_layerSurfacePropertyChanged)
 371             return true;
 372         current = current->m_parent;
 373     }
 374
 375     return false;
 376 }
 377
 378 void LayerImpl::noteLayerPropertyChangedForSubtree()
 379 {
 380     m_layerPropertyChanged = true;
 381     noteLayerPropertyChangedForDescendants();
 382 }
 383
 384 void LayerImpl::noteLayerPropertyChangedForDescendants()
 385 {
 386     for (size_t i = 0; i < m_children.size(); ++i)
 387         m_children[i]->noteLayerPropertyChangedForSubtree();
 388 }
 389
 390 const char* LayerImpl::layerTypeAsString() const
 391 {
 392     return "Layer";
 393 }
 394
 395 void LayerImpl::resetAllChangeTrackingForSubtree()
 396 {
 397     m_layerPropertyChanged = false;
 398     m_layerSurfacePropertyChanged = false;
 399
 400     m_updateRect = gfx::RectF();
 401
 402     if (m_drawProperties.render_surface)
 403         m_drawProperties.render_surface->resetPropertyChangedFlag();
 404
 405     if (m_maskLayer)
 406         m_maskLayer->resetAllChangeTrackingForSubtree();
 407
 408     if (m_replicaLayer)
 409         m_replicaLayer->resetAllChangeTrackingForSubtree(); // also resets the replica mask, if it exists.
 410
 411     for (size_t i = 0; i < m_children.size(); ++i)
 412         m_children[i]->resetAllChangeTrackingForSubtree();
 413 }
 414
 415 bool LayerImpl::layerIsAlwaysDamaged() const
 416 {
 417     return false;
 418 }
 419
 420 int LayerImpl::id() const
 421 {
 422      return m_layerId;
 423 }
 424
 425 float LayerImpl::opacity() const
 426 {
 427      return m_opacity;
 428 }
 429
 430 void LayerImpl::setOpacityFromAnimation(float opacity)
 431 {
 432     setOpacity(opacity);
 433 }
 434
 435 const gfx::Transform& LayerImpl::transform() const
 436 {
 437      return m_transform;
 438 }
 439
 440 void LayerImpl::setTransformFromAnimation(const gfx::Transform& transform)
 441 {
 442     setTransform(transform);
 443 }
 444
 445 void LayerImpl::setBounds(const gfx::Size& bounds)
 446 {
 447     if (m_bounds == bounds)
 448         return;
 449
 450     m_bounds = bounds;
 451
 452     if (masksToBounds())
 453         noteLayerPropertyChangedForSubtree();
 454     else
 455         m_layerPropertyChanged = true;
 456 }
 457
 458 void LayerImpl::setMaskLayer(scoped_ptr<LayerImpl> maskLayer)
 459 {
 460     m_maskLayer = maskLayer.Pass();
 461
 462     int newLayerId = m_maskLayer ? m_maskLayer->id() : -1;
 463     if (newLayerId == m_maskLayerId)
 464         return;
 465
 466     m_maskLayerId = newLayerId;
 467     noteLayerPropertyChangedForSubtree();
 468 }
 469
 470 void LayerImpl::setReplicaLayer(scoped_ptr<LayerImpl> replicaLayer)
 471 {
 472     m_replicaLayer = replicaLayer.Pass();
 473
 474     int newLayerId = m_replicaLayer ? m_replicaLayer->id() : -1;
 475     if (newLayerId == m_replicaLayerId)
 476         return;
 477
 478     m_replicaLayerId = newLayerId;
 479     noteLayerPropertyChangedForSubtree();
 480 }
 481
 482 void LayerImpl::setDrawsContent(bool drawsContent)
 483 {
 484     if (m_drawsContent == drawsContent)
 485         return;
 486
 487     m_drawsContent = drawsContent;
 488     m_layerPropertyChanged = true;
 489 }
 490
 491 void LayerImpl::setAnchorPoint(const gfx::PointF& anchorPoint)
 492 {
 493     if (m_anchorPoint == anchorPoint)
 494         return;
 495
 496     m_anchorPoint = anchorPoint;
 497     noteLayerPropertyChangedForSubtree();
 498 }
 499
 500 void LayerImpl::setAnchorPointZ(float anchorPointZ)
 501 {
 502     if (m_anchorPointZ == anchorPointZ)
 503         return;
 504
 505     m_anchorPointZ = anchorPointZ;
 506     noteLayerPropertyChangedForSubtree();
 507 }
 508
 509 void LayerImpl::setBackgroundColor(SkColor backgroundColor)
 510 {
 511     if (m_backgroundColor == backgroundColor)
 512         return;
 513
 514     m_backgroundColor = backgroundColor;
 515     m_layerPropertyChanged = true;
 516 }
 517
 518 void LayerImpl::setFilters(const WebKit::WebFilterOperations& filters)
 519 {
 520     if (m_filters == filters)
 521         return;
 522
 523     DCHECK(!m_filter);
 524     m_filters = filters;
 525     noteLayerPropertyChangedForSubtree();
 526 }
 527
 528 void LayerImpl::setBackgroundFilters(const WebKit::WebFilterOperations& backgroundFilters)
 529 {
 530     if (m_backgroundFilters == backgroundFilters)
 531         return;
 532
 533     m_backgroundFilters = backgroundFilters;
 534     m_layerPropertyChanged = true;
 535 }
 536
 537 void LayerImpl::setFilter(const skia::RefPtr<SkImageFilter>& filter)
 538 {
 539     if (m_filter.get() == filter.get())
 540         return;
 541
 542     DCHECK(m_filters.isEmpty());
 543     m_filter = filter;
 544     noteLayerPropertyChangedForSubtree();
 545 }
 546
 547 void LayerImpl::setMasksToBounds(bool masksToBounds)
 548 {
 549     if (m_masksToBounds == masksToBounds)
 550         return;
 551
 552     m_masksToBounds = masksToBounds;
 553     noteLayerPropertyChangedForSubtree();
 554 }
 555
 556 void LayerImpl::setContentsOpaque(bool opaque)
 557 {
 558     if (m_contentsOpaque == opaque)
 559         return;
 560
 561     m_contentsOpaque = opaque;
 562     noteLayerPropertyChangedForSubtree();
 563 }
 564
 565 void LayerImpl::setOpacity(float opacity)
 566 {
 567     if (m_opacity == opacity)
 568         return;
 569
 570     m_opacity = opacity;
 571     m_layerSurfacePropertyChanged = true;
 572 }
 573
 574 bool LayerImpl::opacityIsAnimating() const
 575 {
 576     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Opacity);
 577 }
 578
 579 void LayerImpl::setPosition(const gfx::PointF& position)
 580 {
 581     if (m_position == position)
 582         return;
 583
 584     m_position = position;
 585     noteLayerPropertyChangedForSubtree();
 586 }
 587
 588 void LayerImpl::setPreserves3D(bool preserves3D)
 589 {
 590     if (m_preserves3D == preserves3D)
 591         return;
 592
 593     m_preserves3D = preserves3D;
 594     noteLayerPropertyChangedForSubtree();
 595 }
 596
 597 void LayerImpl::setSublayerTransform(const gfx::Transform& sublayerTransform)
 598 {
 599     if (m_sublayerTransform == sublayerTransform)
 600         return;
 601
 602     m_sublayerTransform = sublayerTransform;
 603     // sublayer transform does not affect the current layer; it affects only its children.
 604     noteLayerPropertyChangedForDescendants();
 605 }
 606
 607 void LayerImpl::setTransform(const gfx::Transform& transform)
 608 {
 609     if (m_transform == transform)
 610         return;
 611
 612     m_transform = transform;
 613     m_layerSurfacePropertyChanged = true;
 614 }
 615
 616 bool LayerImpl::transformIsAnimating() const
 617 {
 618     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Transform);
 619 }
 620
 621 void LayerImpl::setContentBounds(const gfx::Size& contentBounds)
 622 {
 623     if (m_contentBounds == contentBounds)
 624         return;
 625
 626     m_contentBounds = contentBounds;
 627     m_layerPropertyChanged = true;
 628 }
 629
 630 void LayerImpl::setContentsScale(float contentsScaleX, float contentsScaleY)
 631 {
 632     if (m_contentsScaleX == contentsScaleX && m_contentsScaleY == contentsScaleY)
 633         return;
 634
 635     m_contentsScaleX = contentsScaleX;
 636     m_contentsScaleY = contentsScaleY;
 637     m_layerPropertyChanged = true;
 638 }
 639
 640 void LayerImpl::setScrollOffset(gfx::Vector2d scrollOffset)
 641 {
 642     if (m_scrollOffset == scrollOffset)
 643         return;
 644
 645     m_scrollOffset = scrollOffset;
 646     noteLayerPropertyChangedForSubtree();
 647 }
 648
 649 void LayerImpl::setScrollDelta(const gfx::Vector2dF& scrollDelta)
 650 {
 651     if (m_scrollDelta == scrollDelta)
 652         return;
 653
 654     m_scrollDelta = scrollDelta;
 655     noteLayerPropertyChangedForSubtree();
 656 }
 657
 658 void LayerImpl::setImplTransform(const gfx::Transform& transform)
 659 {
 660     if (m_implTransform == transform)
 661         return;
 662
 663     m_implTransform = transform;
 664     noteLayerPropertyChangedForSubtree();
 665 }
 666
 667 void LayerImpl::setDoubleSided(bool doubleSided)
 668 {
 669     if (m_doubleSided == doubleSided)
 670         return;
 671
 672     m_doubleSided = doubleSided;
 673     noteLayerPropertyChangedForSubtree();
 674 }
 675
 676 Region LayerImpl::visibleContentOpaqueRegion() const
 677 {
 678     if (contentsOpaque())
 679         return visibleContentRect();
 680     return Region();
 681 }
 682
 683 void LayerImpl::didLoseOutputSurface()
 684 {
 685 }
 686
 687 void LayerImpl::setMaxScrollOffset(gfx::Vector2d maxScrollOffset)
 688 {
 689     m_maxScrollOffset = maxScrollOffset;
 690
 691     if (!m_scrollbarAnimationController)
 692         return;
 693     m_scrollbarAnimationController->updateScrollOffset(this);
 694 }
 695
 696 ScrollbarLayerImpl* LayerImpl::horizontalScrollbarLayer()
 697 {
 698     return m_scrollbarAnimationController ? m_scrollbarAnimationController->horizontalScrollbarLayer() : 0;
 699 }
 700
 701 const ScrollbarLayerImpl* LayerImpl::horizontalScrollbarLayer() const
 702 {
 703     return m_scrollbarAnimationController ? m_scrollbarAnimationController->horizontalScrollbarLayer() : 0;
 704 }
 705
 706 void LayerImpl::setHorizontalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 707 {
 708     if (!m_scrollbarAnimationController)
 709         m_scrollbarAnimationController = ScrollbarAnimationController::create(this);
 710     m_scrollbarAnimationController->setHorizontalScrollbarLayer(scrollbarLayer);
 711     m_scrollbarAnimationController->updateScrollOffset(this);
 712 }
 713
 714 ScrollbarLayerImpl* LayerImpl::verticalScrollbarLayer()
 715 {
 716     return m_scrollbarAnimationController ? m_scrollbarAnimationController->verticalScrollbarLayer() : 0;
 717 }
 718
 719 const ScrollbarLayerImpl* LayerImpl::verticalScrollbarLayer() const
 720 {
 721     return m_scrollbarAnimationController ? m_scrollbarAnimationController->verticalScrollbarLayer() : 0;
 722 }
 723
 724 void LayerImpl::setVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 725 {
 726     if (!m_scrollbarAnimationController)
 727         m_scrollbarAnimationController = ScrollbarAnimationController::create(this);
 728     m_scrollbarAnimationController->setVerticalScrollbarLayer(scrollbarLayer);
 729     m_scrollbarAnimationController->updateScrollOffset(this);
 730 }
 731
 732 }  // namespace cc