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"
 
 #include "ui/gfx/compositor/compositor_cc.h"
 
 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),
       layer_updated_externally_(false),
       opacity_(1.0f),
       delegate_(NULL) {
   CreateWebLayer();
 }
 
@@ skipping 130 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;
 }
 
 // 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 (fills_bounds_opaquely_ == fills_bounds_opaquely)
     return;
 
   fills_bounds_opaquely_ = fills_bounds_opaquely;
 
   web_layer_.setOpaque(fills_bounds_opaquely);
   RecomputeDebugBorderColor();
 }
 
 void Layer::SetExternalTexture(ui::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();
     WebKit::WebLayer new_layer;
     if (layer_updated_externally_)
       new_layer = WebKit::WebExternalTextureLayer::create();
     else
       new_layer = WebKit::WebContentLayer::create(this);
@@ skipping 21 matching lines @@
         web_layer_.to<WebKit::WebExternalTextureLayer>();
     texture_layer.setFlipped(texture_cc->flipped());
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetCanvas(const SkCanvas& canvas, const gfx::Point& origin) {
   NOTREACHED();
 }
 
+void Layer::SetColor(SkColor color) {
+  DCHECK_EQ(type_, LAYER_SOLID_COLOR);
+  // WebColor is equivalent to SkColor, per WebColor.h.
+  web_layer_.to<WebKit::WebSolidColorLayer>().setBackgroundColor(
+      static_cast<WebKit::WebColor>(color));
+  SetFillsBoundsOpaquely(SkColorGetA(color) == 0xFF);
+}
+
 void Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
+  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);
 }
@@ skipping 51 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 85 matching lines @@
 
 const Transform& Layer::GetTransformForAnimation() const {
   return transform();
 }
 
 float Layer::GetOpacityForAnimation() const {
   return opacity();
 }
 
 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;
   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 12 matching lines @@
     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);
 }
 
 }  // namespace ui