src/cc/blink/web_layer_impl.cc

   1 // Copyright 2014 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/blink/web_layer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/trace_event_impl.h"
   9 #include "base/lazy_instance.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/threading/thread_checker.h"
  12 #include "cc/animation/animation.h"
  13 #include "cc/base/region.h"
  14 #include "cc/base/switches.h"
  15 #include "cc/blink/web_animation_impl.h"
  16 #include "cc/blink/web_blend_mode.h"
  17 #include "cc/blink/web_filter_operations_impl.h"
  18 #include "cc/blink/web_to_cc_animation_delegate_adapter.h"
  19 #include "cc/layers/layer.h"
  20 #include "cc/layers/layer_position_constraint.h"
  21 #include "cc/trees/layer_tree_host.h"
  22 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
  23 #include "third_party/WebKit/public/platform/WebFloatRect.h"
  24 #include "third_party/WebKit/public/platform/WebGraphicsLayerDebugInfo.h"
  25 #include "third_party/WebKit/public/platform/WebLayerClient.h"
  26 #include "third_party/WebKit/public/platform/WebLayerPositionConstraint.h"
  27 #include "third_party/WebKit/public/platform/WebLayerScrollClient.h"
  28 #include "third_party/WebKit/public/platform/WebSize.h"
  29 #include "third_party/skia/include/utils/SkMatrix44.h"
  30
  31 using cc::Animation;
  32 using cc::Layer;
  33 using blink::WebLayer;
  34 using blink::WebFloatPoint;
  35 using blink::WebVector;
  36 using blink::WebRect;
  37 using blink::WebSize;
  38 using blink::WebColor;
  39 using blink::WebFilterOperations;
  40
  41 namespace cc_blink {
  42 namespace {
  43
  44 bool g_impl_side_painting_enabled = false;
  45
  46 }  // namespace
  47
  48 WebLayerImpl::WebLayerImpl() : layer_(Layer::Create()) {
  49   web_layer_client_ = NULL;
  50   layer_->SetLayerClient(this);
  51 }
  52
  53 WebLayerImpl::WebLayerImpl(scoped_refptr<Layer> layer) : layer_(layer) {
  54   web_layer_client_ = NULL;
  55   layer_->SetLayerClient(this);
  56 }
  57
  58 WebLayerImpl::~WebLayerImpl() {
  59   layer_->ClearRenderSurface();
  60   layer_->set_layer_animation_delegate(NULL);
  61   web_layer_client_ = NULL;
  62 }
  63
  64 // static
  65 bool WebLayerImpl::UsingPictureLayer() {
  66   return g_impl_side_painting_enabled;
  67 }
  68
  69 // static
  70 void WebLayerImpl::SetImplSidePaintingEnabled(bool enabled) {
  71   g_impl_side_painting_enabled = enabled;
  72 }
  73
  74 int WebLayerImpl::id() const {
  75   return layer_->id();
  76 }
  77
  78 void WebLayerImpl::invalidateRect(const blink::WebFloatRect& rect) {
  79   layer_->SetNeedsDisplayRect(rect);
  80 }
  81
  82 void WebLayerImpl::invalidate() {
  83   layer_->SetNeedsDisplay();
  84 }
  85
  86 void WebLayerImpl::addChild(WebLayer* child) {
  87   layer_->AddChild(static_cast<WebLayerImpl*>(child)->layer());
  88 }
  89
  90 void WebLayerImpl::insertChild(WebLayer* child, size_t index) {
  91   layer_->InsertChild(static_cast<WebLayerImpl*>(child)->layer(), index);
  92 }
  93
  94 void WebLayerImpl::replaceChild(WebLayer* reference, WebLayer* new_layer) {
  95   layer_->ReplaceChild(static_cast<WebLayerImpl*>(reference)->layer(),
  96                        static_cast<WebLayerImpl*>(new_layer)->layer());
  97 }
  98
  99 void WebLayerImpl::removeFromParent() {
 100   layer_->RemoveFromParent();
 101 }
 102
 103 void WebLayerImpl::removeAllChildren() {
 104   layer_->RemoveAllChildren();
 105 }
 106
 107 void WebLayerImpl::setBounds(const WebSize& size) {
 108   layer_->SetBounds(size);
 109 }
 110
 111 WebSize WebLayerImpl::bounds() const {
 112   return layer_->bounds();
 113 }
 114
 115 void WebLayerImpl::setMasksToBounds(bool masks_to_bounds) {
 116   layer_->SetMasksToBounds(masks_to_bounds);
 117 }
 118
 119 bool WebLayerImpl::masksToBounds() const {
 120   return layer_->masks_to_bounds();
 121 }
 122
 123 void WebLayerImpl::setMaskLayer(WebLayer* maskLayer) {
 124   layer_->SetMaskLayer(
 125       maskLayer ? static_cast<WebLayerImpl*>(maskLayer)->layer() : 0);
 126 }
 127
 128 void WebLayerImpl::setReplicaLayer(WebLayer* replica_layer) {
 129   layer_->SetReplicaLayer(
 130       replica_layer ? static_cast<WebLayerImpl*>(replica_layer)->layer() : 0);
 131 }
 132
 133 void WebLayerImpl::setOpacity(float opacity) {
 134   layer_->SetOpacity(opacity);
 135 }
 136
 137 float WebLayerImpl::opacity() const {
 138   return layer_->opacity();
 139 }
 140
 141 void WebLayerImpl::setBlendMode(blink::WebBlendMode blend_mode) {
 142   layer_->SetBlendMode(BlendModeToSkia(blend_mode));
 143 }
 144
 145 blink::WebBlendMode WebLayerImpl::blendMode() const {
 146   return BlendModeFromSkia(layer_->blend_mode());
 147 }
 148
 149 void WebLayerImpl::setIsRootForIsolatedGroup(bool isolate) {
 150   layer_->SetIsRootForIsolatedGroup(isolate);
 151 }
 152
 153 bool WebLayerImpl::isRootForIsolatedGroup() {
 154   return layer_->is_root_for_isolated_group();
 155 }
 156
 157 void WebLayerImpl::setOpaque(bool opaque) {
 158   layer_->SetContentsOpaque(opaque);
 159 }
 160
 161 bool WebLayerImpl::opaque() const {
 162   return layer_->contents_opaque();
 163 }
 164
 165 void WebLayerImpl::setPosition(const WebFloatPoint& position) {
 166   layer_->SetPosition(position);
 167 }
 168
 169 WebFloatPoint WebLayerImpl::position() const {
 170   return layer_->position();
 171 }
 172
 173 void WebLayerImpl::setTransform(const SkMatrix44& matrix) {
 174   gfx::Transform transform;
 175   transform.matrix() = matrix;
 176   layer_->SetTransform(transform);
 177 }
 178
 179 void WebLayerImpl::setTransformOrigin(const blink::WebFloatPoint3D& point) {
 180   gfx::Point3F gfx_point = point;
 181   layer_->SetTransformOrigin(gfx_point);
 182 }
 183
 184 blink::WebFloatPoint3D WebLayerImpl::transformOrigin() const {
 185   return layer_->transform_origin();
 186 }
 187
 188 SkMatrix44 WebLayerImpl::transform() const {
 189   return layer_->transform().matrix();
 190 }
 191
 192 void WebLayerImpl::setDrawsContent(bool draws_content) {
 193   layer_->SetIsDrawable(draws_content);
 194 }
 195
 196 bool WebLayerImpl::drawsContent() const {
 197   return layer_->DrawsContent();
 198 }
 199
 200 void WebLayerImpl::setShouldFlattenTransform(bool flatten) {
 201   layer_->SetShouldFlattenTransform(flatten);
 202 }
 203
 204 void WebLayerImpl::setRenderingContext(int context) {
 205   layer_->Set3dSortingContextId(context);
 206 }
 207
 208 void WebLayerImpl::setUseParentBackfaceVisibility(
 209     bool use_parent_backface_visibility) {
 210   layer_->set_use_parent_backface_visibility(use_parent_backface_visibility);
 211 }
 212
 213 void WebLayerImpl::setBackgroundColor(WebColor color) {
 214   layer_->SetBackgroundColor(color);
 215 }
 216
 217 WebColor WebLayerImpl::backgroundColor() const {
 218   return layer_->background_color();
 219 }
 220
 221 void WebLayerImpl::setFilters(const WebFilterOperations& filters) {
 222   const WebFilterOperationsImpl& filters_impl =
 223       static_cast<const WebFilterOperationsImpl&>(filters);
 224   layer_->SetFilters(filters_impl.AsFilterOperations());
 225 }
 226
 227 void WebLayerImpl::setBackgroundFilters(const WebFilterOperations& filters) {
 228   const WebFilterOperationsImpl& filters_impl =
 229       static_cast<const WebFilterOperationsImpl&>(filters);
 230   layer_->SetBackgroundFilters(filters_impl.AsFilterOperations());
 231 }
 232
 233 void WebLayerImpl::setAnimationDelegate(
 234     blink::WebCompositorAnimationDelegate* delegate) {
 235   animation_delegate_adapter_.reset(
 236       new WebToCCAnimationDelegateAdapter(delegate));
 237   layer_->set_layer_animation_delegate(animation_delegate_adapter_.get());
 238 }
 239
 240 bool WebLayerImpl::addAnimation(blink::WebCompositorAnimation* animation) {
 241   bool result = layer_->AddAnimation(
 242       static_cast<WebCompositorAnimationImpl*>(animation)->PassAnimation());
 243   delete animation;
 244   return result;
 245 }
 246
 247 void WebLayerImpl::removeAnimation(int animation_id) {
 248   layer_->RemoveAnimation(animation_id);
 249 }
 250
 251 void WebLayerImpl::removeAnimation(
 252     int animation_id,
 253     blink::WebCompositorAnimation::TargetProperty target_property) {
 254   layer_->layer_animation_controller()->RemoveAnimation(
 255       animation_id, static_cast<Animation::TargetProperty>(target_property));
 256 }
 257
 258 void WebLayerImpl::pauseAnimation(int animation_id, double time_offset) {
 259   layer_->PauseAnimation(animation_id, time_offset);
 260 }
 261
 262 bool WebLayerImpl::hasActiveAnimation() {
 263   return layer_->HasActiveAnimation();
 264 }
 265
 266 void WebLayerImpl::setForceRenderSurface(bool force_render_surface) {
 267   layer_->SetForceRenderSurface(force_render_surface);
 268 }
 269
 270 void WebLayerImpl::setScrollPosition(blink::WebPoint position) {
 271   layer_->SetScrollOffset(gfx::Point(position).OffsetFromOrigin());
 272 }
 273
 274 blink::WebPoint WebLayerImpl::scrollPosition() const {
 275   return gfx::PointAtOffsetFromOrigin(layer_->scroll_offset());
 276 }
 277
 278 void WebLayerImpl::setScrollClipLayer(WebLayer* clip_layer) {
 279   if (!clip_layer) {
 280     layer_->SetScrollClipLayerId(Layer::INVALID_ID);
 281     return;
 282   }
 283   layer_->SetScrollClipLayerId(clip_layer->id());
 284 }
 285
 286 bool WebLayerImpl::scrollable() const {
 287   return layer_->scrollable();
 288 }
 289
 290 void WebLayerImpl::setUserScrollable(bool horizontal, bool vertical) {
 291   layer_->SetUserScrollable(horizontal, vertical);
 292 }
 293
 294 bool WebLayerImpl::userScrollableHorizontal() const {
 295   return layer_->user_scrollable_horizontal();
 296 }
 297
 298 bool WebLayerImpl::userScrollableVertical() const {
 299   return layer_->user_scrollable_vertical();
 300 }
 301
 302 void WebLayerImpl::setHaveWheelEventHandlers(bool have_wheel_event_handlers) {
 303   layer_->SetHaveWheelEventHandlers(have_wheel_event_handlers);
 304 }
 305
 306 bool WebLayerImpl::haveWheelEventHandlers() const {
 307   return layer_->have_wheel_event_handlers();
 308 }
 309
 310 void WebLayerImpl::setHaveScrollEventHandlers(bool have_scroll_event_handlers) {
 311   layer_->SetHaveScrollEventHandlers(have_scroll_event_handlers);
 312 }
 313
 314 bool WebLayerImpl::haveScrollEventHandlers() const {
 315   return layer_->have_scroll_event_handlers();
 316 }
 317
 318 void WebLayerImpl::setShouldScrollOnMainThread(
 319     bool should_scroll_on_main_thread) {
 320   layer_->SetShouldScrollOnMainThread(should_scroll_on_main_thread);
 321 }
 322
 323 bool WebLayerImpl::shouldScrollOnMainThread() const {
 324   return layer_->should_scroll_on_main_thread();
 325 }
 326
 327 void WebLayerImpl::setNonFastScrollableRegion(const WebVector<WebRect>& rects) {
 328   cc::Region region;
 329   for (size_t i = 0; i < rects.size(); ++i)
 330     region.Union(rects[i]);
 331   layer_->SetNonFastScrollableRegion(region);
 332 }
 333
 334 WebVector<WebRect> WebLayerImpl::nonFastScrollableRegion() const {
 335   size_t num_rects = 0;
 336   for (cc::Region::Iterator region_rects(layer_->non_fast_scrollable_region());
 337        region_rects.has_rect();
 338        region_rects.next())
 339     ++num_rects;
 340
 341   WebVector<WebRect> result(num_rects);
 342   size_t i = 0;
 343   for (cc::Region::Iterator region_rects(layer_->non_fast_scrollable_region());
 344        region_rects.has_rect();
 345        region_rects.next()) {
 346     result[i] = region_rects.rect();
 347     ++i;
 348   }
 349   return result;
 350 }
 351
 352 void WebLayerImpl::setTouchEventHandlerRegion(const WebVector<WebRect>& rects) {
 353   cc::Region region;
 354   for (size_t i = 0; i < rects.size(); ++i)
 355     region.Union(rects[i]);
 356   layer_->SetTouchEventHandlerRegion(region);
 357 }
 358
 359 WebVector<WebRect> WebLayerImpl::touchEventHandlerRegion() const {
 360   size_t num_rects = 0;
 361   for (cc::Region::Iterator region_rects(layer_->touch_event_handler_region());
 362        region_rects.has_rect();
 363        region_rects.next())
 364     ++num_rects;
 365
 366   WebVector<WebRect> result(num_rects);
 367   size_t i = 0;
 368   for (cc::Region::Iterator region_rects(layer_->touch_event_handler_region());
 369        region_rects.has_rect();
 370        region_rects.next()) {
 371     result[i] = region_rects.rect();
 372     ++i;
 373   }
 374   return result;
 375 }
 376
 377 void WebLayerImpl::setIsContainerForFixedPositionLayers(bool enable) {
 378   layer_->SetIsContainerForFixedPositionLayers(enable);
 379 }
 380
 381 bool WebLayerImpl::isContainerForFixedPositionLayers() const {
 382   return layer_->IsContainerForFixedPositionLayers();
 383 }
 384
 385 static blink::WebLayerPositionConstraint ToWebLayerPositionConstraint(
 386     const cc::LayerPositionConstraint& constraint) {
 387   blink::WebLayerPositionConstraint web_constraint;
 388   web_constraint.isFixedPosition = constraint.is_fixed_position();
 389   web_constraint.isFixedToRightEdge = constraint.is_fixed_to_right_edge();
 390   web_constraint.isFixedToBottomEdge = constraint.is_fixed_to_bottom_edge();
 391   return web_constraint;
 392 }
 393
 394 static cc::LayerPositionConstraint ToLayerPositionConstraint(
 395     const blink::WebLayerPositionConstraint& web_constraint) {
 396   cc::LayerPositionConstraint constraint;
 397   constraint.set_is_fixed_position(web_constraint.isFixedPosition);
 398   constraint.set_is_fixed_to_right_edge(web_constraint.isFixedToRightEdge);
 399   constraint.set_is_fixed_to_bottom_edge(web_constraint.isFixedToBottomEdge);
 400   return constraint;
 401 }
 402
 403 void WebLayerImpl::setPositionConstraint(
 404     const blink::WebLayerPositionConstraint& constraint) {
 405   layer_->SetPositionConstraint(ToLayerPositionConstraint(constraint));
 406 }
 407
 408 blink::WebLayerPositionConstraint WebLayerImpl::positionConstraint() const {
 409   return ToWebLayerPositionConstraint(layer_->position_constraint());
 410 }
 411
 412 void WebLayerImpl::setScrollClient(blink::WebLayerScrollClient* scroll_client) {
 413   if (scroll_client) {
 414     layer_->set_did_scroll_callback(
 415         base::Bind(&blink::WebLayerScrollClient::didScroll,
 416                    base::Unretained(scroll_client)));
 417   } else {
 418     layer_->set_did_scroll_callback(base::Closure());
 419   }
 420 }
 421
 422 bool WebLayerImpl::isOrphan() const {
 423   return !layer_->layer_tree_host();
 424 }
 425
 426 void WebLayerImpl::setWebLayerClient(blink::WebLayerClient* client) {
 427   web_layer_client_ = client;
 428 }
 429
 430 class TracedDebugInfo : public base::debug::ConvertableToTraceFormat {
 431  public:
 432   // This object takes ownership of the debug_info object.
 433   explicit TracedDebugInfo(blink::WebGraphicsLayerDebugInfo* debug_info)
 434       : debug_info_(debug_info) {}
 435   virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
 436     DCHECK(thread_checker_.CalledOnValidThread());
 437     blink::WebString web_string;
 438     debug_info_->appendAsTraceFormat(&web_string);
 439     out->append(web_string.utf8());
 440   }
 441
 442  private:
 443   virtual ~TracedDebugInfo() {}
 444   scoped_ptr<blink::WebGraphicsLayerDebugInfo> debug_info_;
 445   base::ThreadChecker thread_checker_;
 446 };
 447
 448 scoped_refptr<base::debug::ConvertableToTraceFormat>
 449 WebLayerImpl::TakeDebugInfo() {
 450   if (!web_layer_client_)
 451     return NULL;
 452   blink::WebGraphicsLayerDebugInfo* debug_info =
 453       web_layer_client_->takeDebugInfoFor(this);
 454
 455   if (debug_info)
 456     return new TracedDebugInfo(debug_info);
 457   else
 458     return NULL;
 459 }
 460
 461 void WebLayerImpl::setScrollParent(blink::WebLayer* parent) {
 462   cc::Layer* scroll_parent = NULL;
 463   if (parent)
 464     scroll_parent = static_cast<WebLayerImpl*>(parent)->layer();
 465   layer_->SetScrollParent(scroll_parent);
 466 }
 467
 468 void WebLayerImpl::setClipParent(blink::WebLayer* parent) {
 469   cc::Layer* clip_parent = NULL;
 470   if (parent)
 471     clip_parent = static_cast<WebLayerImpl*>(parent)->layer();
 472   layer_->SetClipParent(clip_parent);
 473 }
 474
 475 Layer* WebLayerImpl::layer() const {
 476   return layer_.get();
 477 }
 478
 479 }  // namespace cc_blink