Add flag for drawing layers to screen with Ganesh

cc/layers/picture_layer_impl.cc

 // Copyright 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 "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 
 #include "base/time.h"
 #include "cc/base/math_util.h"
@@ skipping 101 matching lines @@
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->drawing_info().IsReadyToDraw()) {
         ManagedTileState::DrawingInfo::Mode mode = iter->drawing_info().mode();
         if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
             mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
         } else if (mode == ManagedTileState::DrawingInfo::PICTURE_PILE_MODE) {
-          color = DebugColors::PictureTileBorderColor();
-          width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
+          if (CanDrawDirectlyToBackbuffer()) {
+            color = DebugColors::DirectPictureTileBorderColor();
+            width =
+                DebugColors::DirectPictureTileBorderWidth(layer_tree_impl());
+          } else {
+            color = DebugColors::PictureTileBorderColor();
+            width = DebugColors::PictureTileBorderWidth(layer_tree_impl());
+          }
         } else if (iter->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION) {
           color = DebugColors::HighResTileBorderColor();
           width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         } else if (iter->priority(ACTIVE_TREE).resolution == LOW_RESOLUTION) {
           color = DebugColors::LowResTileBorderColor();
           width = DebugColors::LowResTileBorderWidth(layer_tree_impl());
         } else if (iter->contents_scale() > contents_scale_x()) {
           color = DebugColors::ExtraHighResTileBorderColor();
           width = DebugColors::ExtraHighResTileBorderWidth(layer_tree_impl());
         } else {
           color = DebugColors::ExtraLowResTileBorderColor();
           width = DebugColors::ExtraLowResTileBorderWidth(layer_tree_impl());
         }
       } else {
         color = DebugColors::MissingTileBorderColor();
         width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
       }
 
       scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
           DebugBorderDrawQuad::Create();
       gfx::Rect geometry_rect = iter.geometry_rect();
       debug_border_quad->SetNew(shared_quad_state, geometry_rect, color, width);
       quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(),
                         append_quads_data);
     }
   }
 
+  if (CanDrawDirectlyToBackbuffer() &&
+      layer_tree_impl()->settings().draw_layers_with_ganesh) {
+    scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
+    gfx::Rect opaque_rect;
+    quad->SetNew(shared_quad_state,
+                 content_rect,
+                 opaque_rect,
+                 gfx::RectF(0, 0, 1, 1),
+                 content_rect.size(),
+                 false,
+                 content_rect,
+                 contents_scale_x(),
+                 CanDrawDirectlyToBackbuffer(),
+                 pile_);
+    if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
+      append_quads_data->num_missing_tiles++;
+    return;
+  }
+
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
   for (PictureLayerTilingSet::CoverageIterator iter(
       tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     if (!*iter || !iter->drawing_info().IsReadyToDraw()) {
@@ skipping 60 matching lines @@
 
         scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
         quad->SetNew(shared_quad_state,
                      geometry_rect,
                      opaque_rect,
                      texture_rect,
                      iter.texture_size(),
                      drawing_info.contents_swizzled(),
                      iter->content_rect(),
                      iter->contents_scale(),
+                     CanDrawDirectlyToBackbuffer(),
                      pile_);
         quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
         break;
       }
       case ManagedTileState::DrawingInfo::SOLID_COLOR_MODE: {
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(shared_quad_state,
                      geometry_rect,
                      drawing_info.get_solid_color());
         quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
@@ skipping 99 matching lines @@
   float ideal_page_scale = layer_tree_impl()->total_page_scale_factor();
   float ideal_device_scale = layer_tree_impl()->device_scale_factor();
   float ideal_source_scale =
       ideal_contents_scale / ideal_page_scale / ideal_device_scale;
 
   ideal_contents_scale_ = std::max(ideal_contents_scale, min_contents_scale);
   ideal_page_scale_ = ideal_page_scale;
   ideal_device_scale_ = ideal_device_scale;
   ideal_source_scale_ = std::max(ideal_source_scale, min_source_scale);
 
+  if (CanDrawDirectlyToBackbuffer() &&
+      layer_tree_impl()->settings().draw_layers_with_ganesh) {
+    if (tilings_)
+      tilings_->RemoveAllTilings();
+
+    *contents_scale_x = ideal_contents_scale_;
+    *contents_scale_y = ideal_contents_scale_;
+    *content_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(),
+                                                       ideal_contents_scale_,
+                                                       ideal_contents_scale_));
+    return;
+  }
+
   ManageTilings(animating_transform_to_screen);
 
   // The content scale and bounds for a PictureLayerImpl is somewhat fictitious.
   // There are (usually) several tilings at different scales.  However, the
   // content bounds is the (integer!) space in which quads are generated.
   // In order to guarantee that we can fill this integer space with any set of
   // tilings (and then map back to floating point texture coordinates), the
   // contents scale must be at least as large as the largest of the tilings.
   float max_contents_scale = min_contents_scale;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
@@ skipping 180 matching lines @@
       return 0;
     return iter->drawing_info().get_resource_id();
   }
   return 0;
 }
 
 bool PictureLayerImpl::AreVisibleResourcesReady() const {
   DCHECK(layer_tree_impl()->IsPendingTree());
   DCHECK(ideal_contents_scale_);
 
+  if (!tilings_->num_tilings())
+    return true;
+
   gfx::Rect rect(visible_content_rect());
 
   float min_acceptable_scale =
       std::min(raster_contents_scale_, ideal_contents_scale_);
 
   TreePriority tree_priority =
       layer_tree_impl()->tile_manager()->GlobalState().tree_priority;
   bool should_force_uploads =
       tree_priority != SMOOTHNESS_TAKES_PRIORITY &&
       layer_tree_impl()->animationRegistrar()->
@@ skipping 353 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc