Remove ui-enable-dip option

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 79 matching lines @@
   return GetRoot(this)->compositor_;
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
   // This function must only be called to set the compositor on the root layer,
   // or to reset it.
   DCHECK(!compositor || !compositor_);
   DCHECK(!compositor || compositor->root_layer() == this);
   DCHECK(!parent_);
   compositor_ = compositor;
-  if (IsDIPEnabled() && compositor)
+  if (compositor)
     OnDeviceScaleFactorChanged(compositor->device_scale_factor());
 }
 
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
   web_layer_.addChild(child->web_layer_);
-  if (IsDIPEnabled())
-    child->OnDeviceScaleFactorChanged(device_scale_factor_);
+  child->OnDeviceScaleFactorChanged(device_scale_factor_);
 }
 
 void Layer::Remove(Layer* child) {
   std::vector<Layer*>::iterator i =
       std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->parent_ = NULL;
   child->web_layer_.removeFromParent();
 }
@@ skipping 208 matching lines @@
          !iter.done(); iter.next()) {
       const SkIRect& sk_damaged = iter.rect();
       gfx::Rect damaged(
           sk_damaged.x(),
           sk_damaged.y(),
           sk_damaged.width(),
           sk_damaged.height());
 
       // TODO(pkotwicz): Remove this once we are no longer linearly upscaling
       // web contents when DIP is enabled (crbug.com/127455).
-      if (IsDIPEnabled() && web_layer_is_accelerated_) {
+      if (web_layer_is_accelerated_) {
         damaged.Inset(-1, -1);
         damaged = damaged.Intersect(bounds_);
       }
 
       gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
       WebKit::WebFloatRect web_rect(
           damaged_in_pixel.x(),
           damaged_in_pixel.y(),
           damaged_in_pixel.width(),
           damaged_in_pixel.height());
@@ skipping 11 matching lines @@
 
 void Layer::SuppressPaint() {
   if (!delegate_)
     return;
   delegate_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SuppressPaint();
 }
 
 void Layer::OnDeviceScaleFactorChanged(float device_scale_factor) {
-  CHECK(IsDIPEnabled());
   if (device_scale_factor_ == device_scale_factor)
     return;
   device_scale_factor_ = device_scale_factor;
   RecomputeTransform();
   RecomputeDrawsContentAndUVRect();
   SchedulePaint(gfx::Rect(bounds_.size()));
   if (delegate_)
     delegate_->OnDeviceScaleFactorChanged(device_scale_factor);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 void Layer::paintContents(WebKit::WebCanvas* web_canvas,
                           const WebKit::WebRect& clip) {
   TRACE_EVENT0("ui", "Layer::paintContents");
   gfx::Canvas canvas(web_canvas);
-  bool scale_canvas = IsDIPEnabled() && scale_canvas_;
+  bool scale_canvas = scale_canvas_;
   if (scale_canvas) {
     canvas.sk_canvas()->scale(SkFloatToScalar(device_scale_factor_),
                               SkFloatToScalar(device_scale_factor_));
   }
   if (delegate_)
     delegate_->OnPaintLayer(&canvas);
   if (scale_canvas)
     canvas.Restore();
 }
 
@@ skipping 152 matching lines @@
     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);
 }
 
 void Layer::RecomputeTransform() {
-  if (IsDIPEnabled()) {
-    ui::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.
-    Transform transform;
-    transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
-                              0, 1.0f / device_scale_factor_, 0,
-                              0, 0, 1);
-    transform.ConcatTransform(transform_);
-    transform.ConcatTranslate(bounds_.x(), bounds_.y());
-    transform.ConcatTransform(scale_translate);
-    web_layer_.setTransform(transform.matrix());
-  } else {
-    Transform t = transform_;
-    t.ConcatTranslate(bounds_.x(), bounds_.y());
-    web_layer_.setTransform(t.matrix());
-  }
+  ui::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.
+  Transform transform;
+  transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
+                            0, 1.0f / device_scale_factor_, 0,
+                            0, 0, 1);
+  transform.ConcatTransform(transform_);
+  transform.ConcatTranslate(bounds_.x(), bounds_.y());
+  transform.ConcatTransform(scale_translate);
+  web_layer_.setTransform(transform.matrix());
 }
 
 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(ConvertSizeToPixel(this, bounds_.size()));
   } else {
@@ skipping 28 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