Add human readable programmatic enum name/values to chrome.automation.

chrome/renderer/extensions/automation_internal_custom_bindings.cc

 // Copyright 2014 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 "chrome/renderer/extensions/automation_internal_custom_bindings.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/common/extensions/manifest_handlers/automation.h"
+#include "content/public/renderer/v8_value_converter.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "extensions/renderer/script_context.h"
+#include "ui/accessibility/ax_enums.h"
 
 namespace extensions {
 
 AutomationInternalCustomBindings::AutomationInternalCustomBindings(
     ScriptContext* context) : ObjectBackedNativeHandler(context) {
   RouteFunction(
       "IsInteractPermitted",
       base::Bind(&AutomationInternalCustomBindings::IsInteractPermitted,
                  base::Unretained(this)));
+  RouteFunction(
+      "GetSchemaAdditions",
+      base::Bind(&AutomationInternalCustomBindings::GetSchemaAdditions,
+                 base::Unretained(this)));
 }
 
 AutomationInternalCustomBindings::~AutomationInternalCustomBindings() {
 }
 
 void AutomationInternalCustomBindings::IsInteractPermitted(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   const Extension* extension = context()->extension();
   CHECK(extension);
   const AutomationInfo* automation_info = AutomationInfo::Get(extension);
   CHECK(automation_info);
   args.GetReturnValue().Set(
       v8::Boolean::New(GetIsolate(), automation_info->interact));
 }
 
+void AutomationInternalCustomBindings::GetSchemaAdditions(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  using v8::Local;
+  using v8::Object;
+  using v8::String;
+
+  Local<Object> ret = Object::New(GetIsolate());

[not at google - send to devlin, 2014/05/29 18:26:21]

s/ret/additions/ ?

[David Tseng, 2014/05/29 19:04:40]

Done.

+
+  Local<Object> event_enum = Object::New(GetIsolate());
+  for (int i = ui::AX_EVENT_NONE;
+      i <= ui::AX_EVENT_LAST;
+      ++i) {

[not at google - send to devlin, 2014/05/29 18:26:21]

should fit on 1 line? (might as well just "git cl format")

[David Tseng, 2014/05/29 19:04:40]

Done.

+    Local<String> value =

[aboxhall, 2014/05/29 18:35:49]

The formatting here is also a little weird, I think. GetIsolate() should be
lined up with ui::ToString(... (did clang format it this way?)

[David Tseng, 2014/05/29 19:04:40]

Done; (git cl formatted)

+        String::NewFromUtf8(GetIsolate(),
+            ui::ToString(static_cast<ui::AXEvent>(i)).c_str());
+    event_enum->Set(value, value);
+  }
+  ret->Set(String::NewFromUtf8(GetIsolate(), "Event"), event_enum);
+
+  Local<Object> role_enum = Object::New(GetIsolate());
+  for (int j = ui::AX_ROLE_NONE;
+      j <= ui::AX_ROLE_LAST;
+      ++j) {
+    Local<String> value =
+        String::NewFromUtf8(GetIsolate(),
+            ui::ToString(static_cast<ui::AXRole>(j)).c_str());
+    role_enum->Set(value, value);
+  }
+  ret->Set(String::NewFromUtf8(GetIsolate(), "Role"), role_enum);
+
+  Local<Object> state_enum = Object::New(GetIsolate());
+  for (int k = ui::AX_STATE_NONE;
+      k <= ui::AX_STATE_LAST;
+      ++k) {
+    Local<String> value =
+        String::NewFromUtf8(GetIsolate(),
+            ui::ToString(static_cast<ui::AXState>(k)).c_str());
+    state_enum->Set(value, value);
+  }

[not at google - send to devlin, 2014/05/29 18:26:21]

you should be able to simplify this a lot with templates over the enum type.
something like

template <typename EnumType>
v8::Local<v8::Object> ToEnumObject(
    v8::Isolate* isolate, EnumType from, EnumType to) {
  v8::Local<v8::Object> object = Object::New(isolate);
  for (int i = from; i <= to; ++i) {
    v8::Local<v8::String> value = v8::String::NewFromUtf8(
        isolate, ui::ToString(static_cast<EnumType>(i).c_str()));
   object->Set(value, value);
  }
  return object;
}

apologies for writing out the code, I'm sure you can do it... but templates are
fun. I can't help myself.

[David Tseng, 2014/05/29 19:04:40]

No worries :); I like templates too (less code is always a win).

+  ret->Set(String::NewFromUtf8(GetIsolate(), "State"), state_enum);
+
+  args.GetReturnValue().Set(ret);
+}
+
 }  // namespace extensions