cc: Fix sublayer scale bug in hit testing

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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/trees/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1621 matching lines @@
     return true;
 
   for (const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
        clip_node->id > 1; clip_node = clip_tree.parent(clip_node)) {
     if (clip_node->data.applies_local_clip) {
       const TransformNode* transform_node =
           transform_tree.Node(clip_node->data.target_id);
       gfx::Rect combined_clip_in_target_space =
           gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
 
-      if (!PointHitsRect(screen_space_point, transform_node->data.to_screen,
-                         combined_clip_in_target_space, NULL))
+      const LayerImpl* target_layer =
+          layer->layer_tree_impl()->LayerById(transform_node->owner_id);
+      DCHECK(!target_layer || target_layer->render_surface());

[ajuma, 2016/04/25 23:58:17]

When is target_layer null here? (That is, when the the transform node have an
invalid owner id?)

[jaydasika, 2016/04/26 00:49:32]

For the root transform node (transform node with id 0 has owner id -1). 

+      gfx::Transform surface_screen_space_transform =
+          target_layer
+              ? SurfaceScreenSpaceTransform(target_layer, transform_tree)
+              : gfx::Transform();
+      if (!PointHitsRect(screen_space_point, surface_screen_space_transform,
+                         combined_clip_in_target_space, NULL)) {
         return true;
+      }
     }
     const LayerImpl* clip_node_owner =
         layer->layer_tree_impl()->LayerById(clip_node->owner_id);
     if (clip_node_owner->render_surface() &&
         !PointHitsRect(
             screen_space_point,
             SurfaceScreenSpaceTransform(clip_node_owner, transform_tree),
             clip_node_owner->render_surface()->content_rect(), NULL)) {
       return true;
     }
@@ skipping 12 matching lines @@
                                           transform_tree);
 }
 
 static bool PointHitsLayer(const LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
                            float* distance_to_intersection,
                            const TransformTree& transform_tree,
                            const ClipTree& clip_tree) {
   gfx::Rect content_rect(layer->bounds());
   if (!PointHitsRect(screen_space_point, layer->ScreenSpaceTransform(),
-                     content_rect, distance_to_intersection))
+                     content_rect, distance_to_intersection)) {
     return false;
+  }
 
   // At this point, we think the point does hit the layer, but we need to walk
   // up the parents to ensure that the layer was not clipped in such a way
   // that the hit point actually should not hit the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer,
                                         transform_tree, clip_tree))
     return false;
 
   // Skip the HUD layer.
   if (layer == layer->layer_tree_impl()->hud_layer())
@@ skipping 389 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking(PropertyTrees::ResetFlags flag) {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking(flag);
 }
 
 }  // namespace cc