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 90 matching lines @@
 
 void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   gfx::Rect rect(visible_content_rect());
   gfx::Rect content_rect(content_bounds());
 
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
-  if (!append_quads_data->allow_tile_draw_quads) {
+  bool use_ganesh = CanDrawDirectlyToBackbuffer() &&
+                    layer_tree_impl()->settings().force_direct_layer_drawing;
+
+  if (use_ganesh || !append_quads_data->allow_tile_draw_quads) {
     gfx::Rect geometry_rect = rect;
     gfx::Rect opaque_rect = contents_opaque() ? geometry_rect : gfx::Rect();
     gfx::Size texture_size = rect.size();
     gfx::RectF texture_rect = gfx::RectF(texture_size);
     gfx::Rect quad_content_rect = rect;
     float contents_scale = contents_scale_x();
 
     scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
     quad->SetNew(shared_quad_state,
                  geometry_rect,
                  opaque_rect,
                  texture_rect,
                  texture_size,
                  false,
                  quad_content_rect,
                  contents_scale,
+                 use_ganesh,
                  pile_);
     if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
       append_quads_data->num_missing_tiles++;
     return;
   }
 
   bool clipped = false;
   gfx::QuadF target_quad = MathUtil::MapQuad(
       draw_transform(),
       gfx::QuadF(rect),
@@ skipping 113 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(),
+                     use_ganesh,
                      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(),
                      false);
@@ skipping 110 matching lines @@
   float ideal_page_scale = page_scale_factor;
   float ideal_device_scale = 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().force_direct_layer_drawing) {
+    if (tilings_)
+      tilings_->RemoveAllTilings();

[danakj, 2013/05/15 20:33:16]

Don't you also want to prevent syncing tilings to this layer?

Seems like this value should be part of the CanHaveTilings() method. And you can
do all this block if !CanHaveTilings().

[enne (OOO), 2013/05/15 22:34:38]

Done.

+
+    *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 550 matching lines @@
 }
 
 void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const {
   LayerImpl::AsValueInto(state);
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   state->Set("invalidation", invalidation_.AsValue().release());
 }
 
 }  // namespace cc