ui: Enable debug borders for the UI compositor through layer tree settings.

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 "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 356 matching lines @@
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   web_layer_->setOpaque(fills_bounds_opaquely);
-  RecomputeDebugBorderColor();
 }
 
 void Layer::SetExternalTexture(Texture* texture) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   layer_updated_externally_ = !!texture;
   texture_ = texture;
   if (web_layer_is_accelerated_ != layer_updated_externally_) {
     // Switch to a different type of layer.
     web_layer_->removeAllChildren();
     scoped_ptr<WebKit::WebContentLayer> old_content_layer(
@@ skipping 21 matching lines @@
     }
     web_layer_= new_layer;
     web_layer_is_accelerated_ = layer_updated_externally_;
     for (size_t i = 0; i < children_.size(); ++i) {
       DCHECK(children_[i]->web_layer_);
       web_layer_->addChild(children_[i]->web_layer_);
     }
     web_layer_->setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
     web_layer_->setOpaque(fills_bounds_opaquely_);
     web_layer_->setOpacity(visible_ ? opacity_ : 0.f);
-    web_layer_->setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
     web_layer_->setForceRenderSurface(force_render_surface_);
     RecomputeTransform();
-    RecomputeDebugBorderColor();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetColor(SkColor color) {
   GetAnimator()->SetColor(color);
 }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if (type_ == LAYER_SOLID_COLOR || (!delegate_ && !texture_))
@@ skipping 187 matching lines @@
 
   RecomputeTransform();
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
   bool schedule_draw = (opacity != opacity_ && IsDrawn());
   opacity_ = opacity;
 
   if (visible_)
     web_layer_->setOpacity(opacity);
-  RecomputeDebugBorderColor();
   if (schedule_draw)
     ScheduleDraw();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   // TODO(piman): Expose a visibility flag on WebLayer.
@@ skipping 85 matching lines @@
   WebKit::WebCompositorSupport* compositor_support =
       WebKit::Platform::current()->compositorSupport();
   if (type_ == LAYER_SOLID_COLOR) {
     solid_color_layer_.reset(compositor_support->createSolidColorLayer());
     web_layer_ = solid_color_layer_->layer();
   } else {
     content_layer_.reset(compositor_support->createContentLayer(this));
     web_layer_ = content_layer_->layer();
   }
   web_layer_is_accelerated_ = false;
-  show_debug_borders_ = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kUIShowLayerBorders);
   web_layer_->setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
   web_layer_->setOpaque(true);
-  web_layer_->setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
 }
 
 void Layer::RecomputeTransform() {
   gfx::Transform scale_translate;
   scale_translate.matrix().set3x3(device_scale_factor_, 0, 0,
                                   0, device_scale_factor_, 0,
                                   0, 0, 1);
   // Start with the inverse matrix of above.
   gfx::Transform transform;
   transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
@@ skipping 27 matching lines @@
         0,
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUVRect(rect);
 
     gfx::Size size_in_pixel = ConvertSizeToPixel(this, size);
     web_layer_->setBounds(size_in_pixel);
   }
 }
 
-void Layer::RecomputeDebugBorderColor() {
-  if (!show_debug_borders_)
-    return;
-  unsigned int color = 0xFF000000;
-  color |= web_layer_is_accelerated_ ? 0x0000FF00 : 0x00FF0000;
-  bool opaque = fills_bounds_opaquely_ && (GetCombinedOpacity() == 1.f);
-  if (!opaque)
-    color |= 0xFF;
-  web_layer_->setDebugBorderColor(color);

[jonathan.backer, 2012/11/14 21:39:12]

Is the purpose of this code to give the UI layer borders a different color than
the renderer layer borders? I feel like we may be losing some functionality
here.

[danakj, 2012/11/14 22:26:39]

As per offline, this was the way to get layer borders previously. It did set
more colors than we got in the compositor. Now we have added a number of new
colors there. We can also plumb through any other debug tools that UI would like
to use such as opaque rects, non-opaque rects, paint rects, etc.

The tiled vs non-tiled borders will still be different (green vs orange), and
now also clipping layers and other container layers will get colors.

We can add any other colors based on state to cc/layer_impl.cc as desired. But
the border colors get overloaded pretty quickly. (This will also now provide
colors for surface borders, and show draw culling.) So adding more visualization
via the hud rects with additional flags seems better.

Once we don't use WebLayerTreeView anymore, they'll all be exposed for free.

-}
-
 }  // namespace ui