Implement automatic load of composed/embedded automation trees

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 <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/api/automation_internal/automation_action_adapter.h"
 #include "chrome/browser/extensions/api/automation_internal/automation_util.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/api/automation_internal.h"
 #include "chrome/common/extensions/manifest_handlers/automation.h"
 #include "content/public/browser/ax_event_notification_details.h"
+#include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_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/common/permissions/permissions_data.h"
+#include "ui/accessibility/ax_tree_id_registry.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/ui/ash/accessibility/automation_manager_ash.h"
 #endif
 
 namespace extensions {
 class AutomationWebContentsObserver;
 }  // namespace extensions
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::AutomationWebContentsObserver);
 
 namespace {
-const int kDesktopProcessID = 0;
-const int kDesktopRoutingID = 0;
-
+const int kDesktopTreeID = 0;
 const char kCannotRequestAutomationOnPage[] =
     "Cannot request automation tree on url \"*\". "
     "Extension manifest must request permission to access this host.";
 }  // namespace
 
 namespace extensions {
 
 bool CanRequestAutomation(const Extension* extension,
                           const AutomationInfo* automation_info,
                           const content::WebContents* contents) {
@@ skipping 106 matching lines @@
   content::RenderFrameHost* rfh = contents->GetMainFrame();
   if (!rfh)
     return RespondNow(Error("Could not enable accessibility for active tab"));
 
   if (!CanRequestAutomation(extension(), automation_info, contents)) {
     return RespondNow(
         Error(kCannotRequestAutomationOnPage, contents->GetURL().spec()));
   }
   AutomationWebContentsObserver::CreateForWebContents(contents);
   contents->EnableTreeOnlyAccessibilityMode();
-  return RespondNow(
-      ArgumentList(api::automation_internal::EnableTab::Results::Create(
-          rfh->GetProcess()->GetID(), rfh->GetRoutingID())));
-  }
+  int ax_tree_id = ui::AXTreeIDRegistry::GetInstance()->GetOrCreateAXTreeID(
+      rfh->GetProcess()->GetID(), rfh->GetRoutingID());
+  return RespondNow(ArgumentList(
+      api::automation_internal::EnableTab::Results::Create(ax_tree_id)));
+}
+
+ExtensionFunction::ResponseAction AutomationInternalEnableFrameFunction::Run() {
+// Limited to desktop tree for now.
+#if defined(OS_CHROMEOS)
+  using api::automation_internal::EnableFrame::Params;
+
+  scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+  ui::AXTreeIDRegistry::FrameID frame_id =
+      ui::AXTreeIDRegistry::GetInstance()->GetFrameID(params->tree_id);
+  LOG(ERROR) << "trying!" << frame_id.first << " " << frame_id.second;
+  content::RenderFrameHost* rfh =
+      content::RenderFrameHost::FromID(frame_id.first, frame_id.second);
+  if (!rfh)
+    return RespondNow(Error("unable to load tab"));
+
+  content::WebContents* contents =
+      content::WebContents::FromRenderFrameHost(rfh);
+  AutomationWebContentsObserver::CreateForWebContents(contents);
+  contents->EnableTreeOnlyAccessibilityMode();
+
+  return RespondNow(NoArguments());
+#endif
+  return RespondNow(Error("enableFrame is only supported on Chrome OS"));
+}
 
 ExtensionFunction::ResponseAction
 AutomationInternalPerformActionFunction::Run() {
   const AutomationInfo* automation_info = AutomationInfo::Get(extension());
   EXTENSION_FUNCTION_VALIDATE(automation_info && automation_info->interact);
 
   using api::automation_internal::PerformAction::Params;
   scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  if (params->args.process_id == kDesktopProcessID &&
-      params->args.routing_id == kDesktopRoutingID) {
+  if (params->args.tree_id == kDesktopTreeID) {
 #if defined(OS_CHROMEOS)
     return RouteActionToAdapter(
         params.get(), AutomationManagerAsh::GetInstance());
 #else
     NOTREACHED();
     return RespondNow(Error("Unexpected action on desktop automation tree;"
                             " platform does not support desktop automation"));
 #endif  // defined(OS_CHROMEOS)
   }
+  ui::AXTreeIDRegistry::FrameID frame_id =
+      ui::AXTreeIDRegistry::GetInstance()->GetFrameID(params->args.tree_id);
   content::RenderFrameHost* rfh =
-      content::RenderFrameHost::FromID(params->args.process_id,
-                                       params->args.routing_id);
+      content::RenderFrameHost::FromID(frame_id.first, frame_id.second);
   if (!rfh)
     return RespondNow(Error("Ignoring action on destroyed node"));
 
   const content::WebContents* contents =
       content::WebContents::FromRenderFrameHost(rfh);
   if (!CanRequestAutomation(extension(), automation_info, contents)) {
     return RespondNow(
         Error(kCannotRequestAutomationOnPage, contents->GetURL().spec()));
   }
 
@@ skipping 40 matching lines @@
     return RespondNow(Error("desktop permission must be requested"));
 
   AutomationManagerAsh::GetInstance()->Enable(browser_context());
   return RespondNow(NoArguments());
 #else
   return RespondNow(Error("getDesktop is unsupported by this platform"));
 #endif  // defined(OS_CHROMEOS)
 }
 
 }  // namespace extensions