cc: update scaled transform to occlusion tracker during append quad.

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 <limits>
 
 #include "base/time/time.h"
@@ skipping 121 matching lines @@
 
   // We always need to push properties.
   // See http://crbug.com/303943
   needs_push_properties_ = true;
 }
 
 void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   DCHECK(!needs_post_commit_initialization_);
 
   float max_contents_scale = MaximumTilingContentsScale();

[sohanjg, 2014/06/24 16:18:01]

If we avoid scaling to max scale here, the black patch issue is not observed.

The only way i could fix it keeping the scale is setting the draw properties
again before setting up SQS, i am not sure maybe LTH still needs the updated
transform/bounds/rects.

But, this causes some flicker in gmail, maybe im still missing something or
there approach is wrong :(

   gfx::Transform scaled_draw_transform = draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
+
   gfx::Size scaled_content_bounds =
-      gfx::ToCeiledSize(gfx::ScaleSize(content_bounds(), max_contents_scale));
+      gfx::ToCeiledSize(gfx::ScaleSize(bounds(), max_contents_scale));

[sohanjg, 2014/06/24 16:18:01]

this is keeping same behavior as old code, where we set scale the layer bounds 
and set it as content bounds in CalcContentScale, this reduces the flcker.

[enne (OOO), 2014/06/24 18:06:11]

This does not seem right to me.  This makes scaled_content_bounds (bounds * max
content scale) and then you intersect with visible_content_rect (in the space of
bounds * content scale [i.e. 1]).  That is incorrect.

[sohanjg, 2014/06/25 13:26:52]

Do you mean the scaled_content_bounds calculation ? or the
scaled_visible_content_rect calculations ?
What is you suggestion here ? Should we avoid the intersection ? but can we have
visible content outside content bounds ?

 
   gfx::Rect scaled_visible_content_rect =
       gfx::ScaleToEnclosingRect(visible_content_rect(), max_contents_scale);
   scaled_visible_content_rect.Intersect(gfx::Rect(scaled_content_bounds));
 
   SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
-  shared_quad_state->SetAll(scaled_draw_transform,
-                            scaled_content_bounds,
-                            scaled_visible_content_rect,
-                            draw_properties().clip_rect,
-                            draw_properties().is_clipped,
-                            draw_properties().opacity,
-                            blend_mode(),
-                            sorting_context_id_);
+  draw_properties().target_space_transform = scaled_draw_transform;

[enne (OOO), 2014/06/24 18:06:11]

Sorry, but no.  Draw properties should only be set in UpdateDrawProperties and
should be considered const outside of that.

[sohanjg, 2014/06/25 13:26:52]

Yes, this was just to try and fix the black patch issue.

+  draw_properties().content_bounds = scaled_content_bounds;
+  draw_properties().visible_content_rect = scaled_visible_content_rect;
+  PopulateSharedQuadState(shared_quad_state);
 
   gfx::Rect rect = scaled_visible_content_rect;
 
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
         quad_sink,
         shared_quad_state,
         append_quads_data,
         DebugColors::DirectPictureBorderColor(),
         DebugColors::DirectPictureBorderWidth(layer_tree_impl()));
@@ skipping 1441 matching lines @@
   return iterator_index_ < iterators_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
 }  // namespace cc