Implement actions for Automation API.

chrome/browser/extensions/api/automation_internal/automation_internal_api.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/browser/extensions/api/automation_internal/automation_internal_api.h"
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/automation_internal.h"
 #include "content/public/browser/ax_event_notification_details.h"
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/accessibility/ax_node_data.h"
 
 namespace extensions {
 class AutomationWebContentsObserver;
 } // namespace extensions
@@ skipping 33 matching lines @@
     if (!CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableAutomationAPI)) {
       return;
     }
 
     std::vector<content::AXEventNotificationDetails>::const_iterator iter =
         details.begin();
     for (; iter != details.end(); iter++) {
       scoped_ptr<base::ListValue> args(new base::ListValue());
       const content::AXEventNotificationDetails& event = *iter;
+      int process_id = event.process_id;
       int routing_id = event.routing_id;
 
       base::DictionaryValue* axTreeUpdate = new base::DictionaryValue();
       // TODO(dtseng): These strings should be auto-generated by the IDL
       // compiler.
-      axTreeUpdate->Set("routing_id",
+      axTreeUpdate->Set("processID",
+                        base::Value::CreateIntegerValue(process_id));
+      axTreeUpdate->Set("routingID",
                         base::Value::CreateIntegerValue(routing_id));
-      axTreeUpdate->SetString("event_type", ToString(iter->event_type));
+      axTreeUpdate->SetString("eventType", ToString(iter->event_type));

[not at google - send to devlin, 2014/04/03 18:57:13]

you should be able to construct these arguments without involving the Value API,
too:

AXEventParams args;
params.process_id = event.process_id;
params.routing_id = event.routing_id;
params.event_type = ...;
for (...) {
  linked_ptr<AXNodeData> node(new AXNodeData());
  ...
  args.nodes.push_back(node);
}
DispatchEvent(browser_context_,
              OnAccessibilityEvent::kEventName,
              OnAccessibilityEvent::Create(args));

[aboxhall, 2014/04/03 19:06:31]

This seems outside of scope for this change.

[not at google - send to devlin, 2014/04/03 19:08:02]

fair enough.

[David Tseng, 2014/04/03 23:05:19]

I have this pretty much ready for am putting it off for the next cl so I can
unblock other changes.

One question though (not affecting this cl), after creating args above, it looks
like we'll need to convert back to base Values again to populate the event.
Wouldn't it be more efficient to just populate a base Values in the first place
like we do now? (obviously, the hand rolled attribute names are bad, but it
seems less wasteful).

[not at google - send to devlin, 2014/04/04 16:30:57]

You're saying that with the current code you go

accessibility model --> base::Value

and if you were to use the compiler you'd go

accessibility model --> compiled model --> base::Value

for which the "compiled model" step is wasteful? Yes I think that's true, and if
it's a lot of data that you're frequently ferrying across it might make a small
difference, but without profiling it's hard to tell. I'd say the other
serialization/deserialization that goes on across the various IPC boundaries
would be a significantly more costly operation, and by going through the
"compiled model" step the code becomes simpler and guaranteed to be structurally
correct. An overall win IMO.

[David Tseng, 2014/04/04 17:02:26]

Correct.

 Yes I think that's true, and if
It's potentially a lot of data (mostly on "load_complete" or load of a page).

 I'd say the other
That makes sense; inter-process communication in it of itself (+
unserializing/serializing) is probably the larger cost here, so I'll followup
with the suggested change in the next cl.

       base::ListValue* nodes = new base::ListValue();
       axTreeUpdate->Set("nodes", nodes);
       for (size_t i = 0; i < event.nodes.size(); i++) {
         const ui::AXNodeData& node = event.nodes[i];
         AddNodeData(node, nodes);
       }
       args->Append(axTreeUpdate);
       DispatchEvent(browser_context_,
                     api::automation_internal::OnAccessibilityEvent::kEventName,
                     args.Pass());
     }
     return;
   }
 
  private:
   friend class content::WebContentsUserData<AutomationWebContentsObserver>;
 
   AutomationWebContentsObserver(
       content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         browser_context_(web_contents->GetBrowserContext()) {}
 
   void AddNodeData(const ui::AXNodeData& node,

[not at google - send to devlin, 2014/04/03 18:57:13]

you should be able to return, say, a scoped_ptr<AXNodeData> here (where
AXNodeData is again generated)

                    base::ListValue* nodes) {
     base::DictionaryValue* axNodeData = new base::DictionaryValue();
     axNodeData->SetInteger("id", node.id);
     axNodeData->SetString("role", ToString(node.role));
 
     base::DictionaryValue* state_dict = new base::DictionaryValue();
     uint32 state_pos = 0, state_shifter = node.state;
     while (state_shifter) {
       if (state_shifter & 1)
         state_dict->SetBoolean(ToString(static_cast<ui::AXState>(state_pos)),
                                true);
       state_shifter = state_shifter >> 1;
       state_pos++;
     }
     axNodeData->Set("state", state_dict);
 
     if (!node.bool_attributes.empty()) {
       base::DictionaryValue* bool_attributes = new base::DictionaryValue();
       for (size_t i = 0; i < node.bool_attributes.size(); ++i) {
         std::pair<ui::AXBoolAttribute, bool> attr = node.bool_attributes[i];
         bool_attributes->SetBoolean(ToString(attr.first), attr.second);
       }
-      axNodeData->Set("bool_attributes", bool_attributes);
+      axNodeData->Set("boolAttributes", bool_attributes);
     }
 
     if (!node.float_attributes.empty()) {
       base::DictionaryValue* float_attributes = new base::DictionaryValue();
       for (size_t i = 0; i < node.float_attributes.size(); ++i) {
         std::pair<ui::AXFloatAttribute, float> attr = node.float_attributes[i];
         float_attributes->SetDouble(ToString(attr.first), attr.second);
       }
-      axNodeData->Set("float_attributes", float_attributes);
+      axNodeData->Set("floatAttributes", float_attributes);
     }
 
     if (!node.html_attributes.empty()) {
       base::DictionaryValue* html_attributes = new base::DictionaryValue();
       for (size_t i = 0; i < node.html_attributes.size(); ++i) {
         std::pair<std::string, std::string> attr = node.html_attributes[i];
         html_attributes->SetString(attr.first, attr.second);
       }
-      axNodeData->Set("html_attributes", html_attributes);
+      axNodeData->Set("htmlAttributes", html_attributes);
     }
 
     if (!node.int_attributes.empty()) {
       base::DictionaryValue* int_attributes = new base::DictionaryValue();
       for (size_t i = 0; i < node.int_attributes.size(); ++i) {
         std::pair<ui::AXIntAttribute, int> attr = node.int_attributes[i];
         int_attributes->SetInteger(ToString(attr.first), attr.second);
       }
-      axNodeData->Set("int_attributes", int_attributes);
+      axNodeData->Set("intAttributes", int_attributes);
     }
 
     if (!node.intlist_attributes.empty()) {
       base::DictionaryValue* intlist_attributes = new base::DictionaryValue();
       for (size_t i = 0; i < node.intlist_attributes.size(); ++i) {
         std::pair<ui::AXIntListAttribute, std::vector<int32> > attr =
             node.intlist_attributes[i];
         base::ListValue* intlist = new base::ListValue();
         for (size_t j = 0; j < attr.second.size(); j++)
           intlist->AppendInteger(attr.second[j]);
         intlist_attributes->Set(ToString(attr.first), intlist);
       }
-      axNodeData->Set("intlist_attributes", intlist_attributes);
+      axNodeData->Set("intlistAttributes", intlist_attributes);
     }
 
     if (!node.string_attributes.empty()) {
       base::DictionaryValue* string_attributes = new base::DictionaryValue();
       for (size_t i = 0; i < node.string_attributes.size(); ++i) {
         std::pair<ui::AXStringAttribute, std::string> attr =
             node.string_attributes[i];
         string_attributes->SetString(ToString(attr.first), attr.second);
       }
-      axNodeData->Set("string_attributes", string_attributes);
+      axNodeData->Set("stringAttributes", string_attributes);
     }
 
     base::ListValue* child_ids = new base::ListValue();
     for (size_t i = 0; i < node.child_ids.size(); ++i) {
       child_ids->AppendInteger(node.child_ids[i]);
     }
-    axNodeData->Set("child_ids", child_ids);
+    axNodeData->Set("childIDs", child_ids);
 
     nodes->Append(axNodeData);
   }
 
   content::BrowserContext* browser_context_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationWebContentsObserver);
 };
 
 // TODO(aboxhall/dtseng): ensure that the initial data is sent down for the tab
@@ skipping 15 matching lines @@
   content::RenderWidgetHost* rwh =
       contents->GetRenderWidgetHostView()->GetRenderWidgetHost();
   if (!rwh)
     return false;
 
   AutomationWebContentsObserver::CreateForWebContents(contents);
 
   rwh->EnableTreeOnlyAccessibilityMode();
 
   results_ = api::automation_internal::EnableCurrentTab::Results::Create(
-      rwh->GetRoutingID());
+      rwh->GetProcess()->GetID(), rwh->GetRoutingID());
 
   SendResponse(true);
   return true;
 }
 
+bool AutomationInternalPerformActionFunction::RunImpl() {
+  using api::automation_internal::PerformAction::Params;
+  scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  content::RenderWidgetHost* rwh =
+      content::RenderWidgetHost::FromID(params->args.process_id,
+                                        params->args.routing_id);
+
+  switch (params->args.action_type) {
+    case api::automation_internal::ACTION_TYPE_DO_DEFAULT:
+      rwh->AccessibilityDoDefaultAction(params->args.automation_node_id);
+      break;
+    case api::automation_internal::ACTION_TYPE_FOCUS:
+      rwh->AccessibilitySetFocus(params->args.automation_node_id);
+      break;
+    case api::automation_internal::ACTION_TYPE_MAKE_VISIBLE:
+      rwh->AccessibilityScrollToMakeVisible(params->args.automation_node_id,
+                                            gfx::Rect());
+      break;
+    case api::automation_internal::ACTION_TYPE_SET_SELECTION: {
+      extensions::api::automation_internal::SetSelectionParams selection_params;
+      EXTENSION_FUNCTION_VALIDATE(
+          extensions::api::automation_internal::SetSelectionParams::Populate(
+              params->opt_args.additional_properties, &selection_params));
+      rwh->AccessibilitySetTextSelection(params->args.automation_node_id,
+                                         selection_params.start_index,
+                                         selection_params.end_index);
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+  return true;
+}
+
 }  // namespace extensions