Merge Compositor and CompositorCC

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 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) {
@@ skipping 178 matching lines @@
 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) {
+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();
     WebKit::WebLayer new_layer;
-    if (layer_updated_externally_)
-      new_layer = WebKit::WebExternalTextureLayer::create();
-    else
+    if (layer_updated_externally_) {
+      WebKit::WebExternalTextureLayer texture_layer =
+          WebKit::WebExternalTextureLayer::create();
+      texture_layer.setFlipped(texture_->flipped());
+      new_layer = texture_layer;
+    } else {
       new_layer = WebKit::WebContentLayer::create(this);
+    }
     if (parent_) {
       DCHECK(!parent_->web_layer_.isNull());
       parent_->web_layer_.replaceChild(web_layer_, new_layer);
     }
     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_.isNull());
       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);
     RecomputeTransform();
     RecomputeDebugBorderColor();
   }
-  if (texture) {
-    TextureCC* texture_cc = static_cast<TextureCC*>(texture);
-    texture_cc->Update();
-    WebKit::WebExternalTextureLayer texture_layer =
-        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)
@@ skipping 198 matching lines @@
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(!web_layer_.isNull());
   bool should_draw = type_ != LAYER_NOT_DRAWN;
   if (!web_layer_is_accelerated_) {
     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();
+    unsigned int texture_id = texture_->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()));
+    gfx::Size texture_size = texture_->size();
+    gfx::Size size(std::min(bounds_.width(), texture_size.width()),
+                   std::min(bounds_.height(), texture_size.height()));
     WebKit::WebFloatRect rect(
         0,
         0,
-        static_cast<float>(size.width())/texture_cc->size().width(),
-        static_cast<float>(size.height())/texture_cc->size().height());
+        static_cast<float>(size.width())/texture_size.width(),
+        static_cast<float>(size.height())/texture_size.height());
     texture_layer.setUVRect(rect);
     web_layer_.setBounds(size);
   }
 }
 
 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);
 }
 
 }  // namespace ui