aura: Add Layer::LAYER_SOLID_COLOR to compositor.

ui/gfx/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/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebContentLayer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebExternalTextureLayer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSize.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSolidColorLayer.h"
 #include "ui/base/animation/animation.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/compositor/compositor_switches.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/point3.h"
 
 #if defined(USE_WEBKIT_COMPOSITOR)
 #include "ui/gfx/compositor/compositor_cc.h"
 #endif
 
 namespace {
 
 const float EPSILON = 1e-3f;
 
-bool IsApproximateMultilpleOf(float value, float base) {
+bool IsApproximateMultipleOf(float value, float base) {
   float remainder = fmod(fabs(value), base);
   return remainder < EPSILON || base - remainder < EPSILON;
 }
 
 const ui::Layer* GetRoot(const ui::Layer* layer) {
   return layer->parent() ? GetRoot(layer->parent()) : layer;
 }
 
 }  // namespace
 
 namespace ui {
 
 Layer::Layer()
-    : type_(LAYER_HAS_TEXTURE),
+    : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       fills_bounds_opaquely_(true),
       recompute_hole_(false),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   CreateWebLayer();
@@ skipping 158 matching lines @@
 }
 
 bool Layer::IsDrawn() const {
   const Layer* layer = this;
   while (layer && layer->visible_)
     layer = layer->parent_;
   return layer == NULL;
 }
 
 bool Layer::ShouldDraw() const {
-  return type_ == LAYER_HAS_TEXTURE && GetCombinedOpacity() > 0.0f &&
+  return type_ != LAYER_NOT_DRAWN && GetCombinedOpacity() > 0.0f &&
       !hole_rect_.Contains(gfx::Rect(gfx::Point(0, 0), bounds_.size()));
 }
 
 // static
 void Layer::ConvertPointToLayer(const Layer* source,
                                 const Layer* target,
                                 gfx::Point* point) {
   if (source == target)
     return;
 
   const Layer* root_layer = GetRoot(source);
   CHECK_EQ(root_layer, GetRoot(target));
 
   if (source != root_layer)
     source->ConvertPointForAncestor(root_layer, point);
   if (target != root_layer)
     target->ConvertPointFromAncestor(root_layer, point);
 }
 
 void Layer::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
+  if (type_ == LAYER_SOLID_COLOR)
+    return;

[piman, 2012/01/26 02:16:07]

Mmh, I feel like we should setOpaque somewhere. I'm not sure what happens if the
opaque() value on the layer doesn't match the opaque() value computed on the
quad (coming from the color). It doesn't seem like it's propagated in the webkit
side. James?

[Daniel Erat, 2012/01/26 18:10:26]

Thanks, makes sense.  I've added a call to setOpaque() here and will reupload
after testing with a change that creates a layer with a non-opaque color.

+
   if (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   SetNeedsToRecomputeHole();
 #if defined(USE_WEBKIT_COMPOSITOR)
   web_layer_.setOpaque(fills_bounds_opaquely);
   RecomputeDebugBorderColor();
 #endif
 }
 
 void Layer::SetExternalTexture(ui::Texture* texture) {
+  DCHECK_EQ(type_, LAYER_TEXTURED);
   layer_updated_externally_ = !!texture;
   texture_ = texture;
 #if defined(USE_WEBKIT_COMPOSITOR)
   if (web_layer_is_accelerated_ != layer_updated_externally_) {
     // Switch to a different type of layer.
     web_layer_.removeAllChildren();
     WebKit::WebLayer new_layer;
     if (layer_updated_externally_)
       new_layer = WebKit::WebExternalTextureLayer::create();
     else
@@ skipping 23 matching lines @@
     texture_layer.setFlipped(texture_cc->flipped());
   }
   RecomputeDrawsContentAndUVRect();
 #endif
 }
 
 void Layer::SetCanvas(const SkCanvas& canvas, const gfx::Point& origin) {
 #if defined(USE_WEBKIT_COMPOSITOR)
   NOTREACHED();
 #else
-  DCHECK_EQ(type_, LAYER_HAS_TEXTURE);
+  DCHECK_EQ(type_, LAYER_TEXTURED);
 
   if (!texture_.get())
     texture_ = GetCompositor()->CreateTexture();
 
   texture_->SetCanvas(canvas, origin, bounds_.size());
   invalid_rect_ = gfx::Rect();
 #endif
 }
 
+void Layer::SetColor(SkColor color) {
+  DCHECK_EQ(type_, LAYER_SOLID_COLOR);
+#if defined(USE_WEBKIT_COMPOSITOR)
+  // WebColor is equivalent to SkColor, per WebColor.h.
+  web_layer_.to<WebKit::WebSolidColorLayer>().setBackgroundColor(
+      static_cast<WebKit::WebColor>(color));
+#endif
+}
+
 void Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
 #if defined(USE_WEBKIT_COMPOSITOR)
+  if (type_ == LAYER_SOLID_COLOR)
+    return;
+
   WebKit::WebFloatRect web_rect(
       invalid_rect.x(),
       invalid_rect.y(),
       invalid_rect.width(),
       invalid_rect.height());
   if (!web_layer_is_accelerated_)
     web_layer_.to<WebKit::WebContentLayer>().invalidateRect(web_rect);
   else
     web_layer_.to<WebKit::WebExternalTextureLayer>().invalidateRect(web_rect);
 #else
@@ skipping 174 matching lines @@
     return;
 
   ui::Transform current_transform;
   if (transform().HasChange())
     current_transform.ConcatTransform(transform());
   current_transform.ConcatTranslate(
       static_cast<float>(bounds().x()),
       static_cast<float>(bounds().y()));
   current_transform.ConcatTransform(parent_transform);
 
-  if (fills_bounds_opaquely_ && type_ == LAYER_HAS_TEXTURE) {
+  if (fills_bounds_opaquely_ && type_ != LAYER_NOT_DRAWN) {
     LayerProperties properties;
     properties.layer = this;
     properties.transform_relative_to_root = current_transform;
     traversal->push_back(properties);
   }
 
   for (size_t i = 0; i < children_.size(); i++)
     children_[i]->GetLayerProperties(current_transform, traversal);
 }
 
@@ skipping 24 matching lines @@
       if (!traversal[i].transform_relative_to_root.GetInverse(&inverted))
         continue;
 
       candidate_hole_transform.ConcatTransform(inverted);
 
       // cannot punch a hole if the relative transform between the two layers
       // is not multiple of 90.
       float degrees;
       gfx::Point p;
       if (!InterpolatedTransform::FactorTRS(candidate_hole_transform, &p,
-          &degrees, NULL) || !IsApproximateMultilpleOf(degrees, 90.0f))
+          &degrees, NULL) || !IsApproximateMultipleOf(degrees, 90.0f))
         continue;
 
       candidate_hole_transform.TransformRect(&candidate_hole);
       candidate_hole = candidate_hole.Intersect(bounds);
 
       if (candidate_hole.size().GetArea() >
           layer->hole_rect().size().GetArea()) {
         layer->set_hole_rect(candidate_hole);
       }
     }
     // Free up texture memory if the hole fills bounds of layer.
     if (!layer->ShouldDraw() && !layer_updated_externally())
       layer->DropTexture();
 
 #if defined(USE_WEBKIT_COMPOSITOR)
-  RecomputeDrawsContentAndUVRect();
+    RecomputeDrawsContentAndUVRect();
 #endif
   }
 
   recompute_hole_ = false;
 }
 
 // static
 void Layer::PunchHole(const gfx::Rect& rect,
                       const gfx::Rect& region_to_punch_out,
                       std::vector<gfx::Rect>* sides) {
@@ skipping 143 matching lines @@
 const Transform& Layer::GetTransformForAnimation() const {
   return transform();
 }
 
 float Layer::GetOpacityForAnimation() const {
   return opacity();
 }
 
 #if defined(USE_WEBKIT_COMPOSITOR)
 void Layer::CreateWebLayer() {
-  web_layer_ = WebKit::WebContentLayer::create(this);
+  if (type_ == LAYER_SOLID_COLOR)
+    web_layer_ = WebKit::WebSolidColorLayer::create();
+  else
+    web_layer_ = WebKit::WebContentLayer::create(this);
   web_layer_.setAnchorPoint(WebKit::WebFloatPoint(0.f, 0.f));
   web_layer_.setOpaque(true);
   web_layer_is_accelerated_ = false;
   show_debug_borders_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUIShowLayerBorders);
   web_layer_.setDebugBorderWidth(show_debug_borders_ ? 2 : 0);
   RecomputeDrawsContentAndUVRect();
   RecomputeDebugBorderColor();
 }
 
 void Layer::RecomputeTransform() {
   ui::Transform transform = transform_;
   transform.ConcatTranslate(bounds_.x(), bounds_.y());
   web_layer_.setTransform(transform.matrix());
 }
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(!web_layer_.isNull());
-  bool should_draw = type_ == LAYER_HAS_TEXTURE &&
+  bool should_draw = type_ != LAYER_NOT_DRAWN &&
       !hole_rect_.Contains(gfx::Rect(gfx::Point(0, 0), bounds_.size()));
+
   if (!web_layer_is_accelerated_) {
-    web_layer_.to<WebKit::WebContentLayer>().setDrawsContent(should_draw);
+    if (type_ != LAYER_SOLID_COLOR)
+      web_layer_.to<WebKit::WebContentLayer>().setDrawsContent(should_draw);
     web_layer_.setBounds(bounds_.size());
   } else {
     DCHECK(texture_);
     TextureCC* texture_cc = static_cast<TextureCC*>(texture_.get());
     unsigned int texture_id = texture_cc->texture_id();
     WebKit::WebExternalTextureLayer texture_layer =
         web_layer_.to<WebKit::WebExternalTextureLayer>();
     texture_layer.setTextureId(should_draw ? texture_id : 0);
     gfx::Size size(std::min(bounds_.width(), texture_cc->size().width()),
                    std::min(bounds_.height(), texture_cc->size().height()));
@@ skipping 13 matching lines @@
   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);
 }
 #endif
 
 }  // namespace ui