Communicate whether passive event listeners exist to cc.

cc/test/layer_tree_json_parser.cc

 // Copyright 2013 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/test/layer_tree_json_parser.h"
 
 #include <stddef.h>
 
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_settings.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/trees/layer_tree_settings.h"
 
 namespace cc {
 
 namespace {
 
+bool GetEventListenerProperties(base::DictionaryValue* dict,
+                                const char* property,
+                                EventListenerProperties* listener_properties) {
+  *listener_properties = EventListenerProperties::NONE;
+  base::ListValue* list;
+  bool success = true;
+  if (dict->HasKey(property)) {
+    success &= dict->GetList(property, &list);
+    std::string str;
+    for (size_t i = 0; i < list->GetSize(); i++) {
+      success &= list->GetString(i, &str);
+      if (str == "Blocking")
+        *listener_properties |= EventListenerProperties::BLOCKING;
+      else if (str == "Passive")
+        *listener_properties |= EventListenerProperties::PASSIVE;
+      else
+        success = false;
+    }
+  }
+  return success;
+}
+
 scoped_refptr<Layer> ParseTreeFromValue(base::Value* val,
                                         ContentLayerClient* content_client) {
   base::DictionaryValue* dict;
   bool success = true;
   success &= val->GetAsDictionary(&dict);
   std::string layer_type;
   success &= dict->GetString("LayerType", &layer_type);
   base::ListValue* list;
   success &= dict->GetList("Bounds", &list);
   int width, height;
@@ skipping 85 matching lines @@
   //
   // For now, we can safely indicate a layer is scrollable by giving it a
   // pointer to itself, something not normally allowed in a working tree.
   //
   // https://code.google.com/p/chromium/issues/detail?id=330622
   //
   if (dict->GetBoolean("Scrollable", &scrollable))
     new_layer->SetScrollClipLayerId(scrollable ? new_layer->id()
                                                : Layer::INVALID_ID);
 
-  bool wheel_handler;
-  if (dict->GetBoolean("WheelHandler", &wheel_handler))
-    new_layer->SetHaveWheelEventHandlers(wheel_handler);
+  EventListenerProperties listener_properties;
+  success &=
+      GetEventListenerProperties(dict, "TouchHandler", &listener_properties);
+  new_layer->SetTouchEventProperties(listener_properties);
+
+  success &=
+      GetEventListenerProperties(dict, "WheelHandler", &listener_properties);
+  new_layer->SetWheelEventProperties(listener_properties);
 
   bool scroll_handler;
   if (dict->GetBoolean("ScrollHandler", &scroll_handler))
     new_layer->SetHaveScrollEventHandlers(scroll_handler);
 
   bool is_3d_sorted;
   if (dict->GetBoolean("Is3DSorted", &is_3d_sorted)) {
     // A non-zero context ID will put the layer into a 3D sorting context
     new_layer->Set3dSortingContextId(is_3d_sorted ? 1 : 0);
   }
@@ skipping 52 matching lines @@
 
 }  // namespace
 
 scoped_refptr<Layer> ParseTreeFromJson(std::string json,
                                        ContentLayerClient* content_client) {
   scoped_ptr<base::Value> val = base::test::ParseJson(json);
   return ParseTreeFromValue(val.get(), content_client);
 }
 
 }  // namespace cc