1// Copyright (c) 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/accessibility/accessibility_ui.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/json/json_writer.h"
10#include "base/strings/string_number_conversions.h"
11#include "base/strings/utf_string_conversions.h"
12#include "base/values.h"
13#include "content/browser/accessibility/accessibility_tree_formatter.h"
14#include "content/browser/accessibility/browser_accessibility_manager.h"
15#include "content/browser/accessibility/browser_accessibility_state_impl.h"
16#include "content/browser/renderer_host/render_widget_host_impl.h"
17#include "content/common/view_message_enums.h"
18#include "content/port/browser/render_widget_host_view_port.h"
19#include "content/public/browser/browser_thread.h"
20#include "content/public/browser/favicon_status.h"
21#include "content/public/browser/navigation_entry.h"
22#include "content/public/browser/render_process_host.h"
23#include "content/public/browser/render_view_host.h"
24#include "content/public/browser/render_widget_host.h"
25#include "content/public/browser/web_contents.h"
26#include "content/public/browser/web_ui_data_source.h"
27#include "content/public/common/url_constants.h"
28#include "grit/content_resources.h"
29#include "net/base/escape.h"
30
31static const char kDataFile[] = "targets-data.json";
32
33static const char kProcessIdField[]  = "processId";
34static const char kRouteIdField[]  = "routeId";
35static const char kUrlField[]  = "url";
36static const char kNameField[]  = "name";
37static const char kFaviconUrlField[] = "favicon_url";
38static const char kPidField[]  = "pid";
39static const char kAccessibilityModeField[] = "a11y_mode";
40
41namespace content {
42
43namespace {
44
45base::DictionaryValue* BuildTargetDescriptor(
46    const GURL& url,
47    const std::string& name,
48    const GURL& favicon_url,
49    int process_id,
50    int route_id,
51    AccessibilityMode accessibility_mode,
52    base::ProcessHandle handle = base::kNullProcessHandle) {
53  base::DictionaryValue* target_data = new base::DictionaryValue();
54  target_data->SetInteger(kProcessIdField, process_id);
55  target_data->SetInteger(kRouteIdField, route_id);
56  target_data->SetString(kUrlField, url.spec());
57  target_data->SetString(kNameField, net::EscapeForHTML(name));
58  target_data->SetInteger(kPidField, base::GetProcId(handle));
59  target_data->SetString(kFaviconUrlField, favicon_url.spec());
60  target_data->SetInteger(kAccessibilityModeField,
61                          accessibility_mode);
62  return target_data;
63}
64
65base::DictionaryValue* BuildTargetDescriptor(RenderViewHost* rvh) {
66  WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
67  std::string title;
68  RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rvh);
69  AccessibilityMode accessibility_mode = rwhi->accessibility_mode();
70
71  GURL url;
72  GURL favicon_url;
73  if (web_contents) {
74    url = web_contents->GetURL();
75    title = UTF16ToUTF8(web_contents->GetTitle());
76    NavigationController& controller = web_contents->GetController();
77    NavigationEntry* entry = controller.GetActiveEntry();
78    if (entry != NULL && entry->GetURL().is_valid())
79      favicon_url = entry->GetFavicon().url;
80  }
81
82  return BuildTargetDescriptor(url,
83                               title,
84                               favicon_url,
85                               rvh->GetProcess()->GetID(),
86                               rvh->GetRoutingID(),
87                               accessibility_mode);
88}
89
90void SendTargetsData(
91    const WebUIDataSource::GotDataCallback& callback) {
92  scoped_ptr<base::ListValue> rvh_list(new base::ListValue());
93
94  RenderWidgetHost::List widgets = RenderWidgetHost::GetRenderWidgetHosts();
95  for (size_t i = 0; i < widgets.size(); ++i) {
96    // Ignore processes that don't have a connection, such as crashed tabs.
97    if (!widgets[i]->GetProcess()->HasConnection())
98      continue;
99    if (!widgets[i]->IsRenderView())
100        continue;
101
102    RenderViewHost* rvh = RenderViewHost::From(widgets[i]);
103    rvh_list->Append(BuildTargetDescriptor(rvh));
104  }
105
106  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
107  data->Set("list", rvh_list.release());
108  scoped_ptr<base::FundamentalValue> a11y_mode(new base::FundamentalValue(
109      BrowserAccessibilityStateImpl::GetInstance()->accessibility_mode()));
110  data->Set("global_a11y_mode", a11y_mode.release());
111
112  std::string json_string;
113  base::JSONWriter::Write(data.get(), &json_string);
114
115  callback.Run(base::RefCountedString::TakeString(&json_string));
116}
117
118bool HandleRequestCallback(
119    const std::string& path,
120    const WebUIDataSource::GotDataCallback& callback) {
121  if (path != kDataFile)
122    return false;
123
124  SendTargetsData(callback);
125  return true;
126}
127
128}  // namespace
129
130AccessibilityUI::AccessibilityUI(WebUI* web_ui)
131  : WebUIController(web_ui) {
132  // Set up the chrome://accessibility source.
133  WebUIDataSource* html_source =
134      WebUIDataSource::Create(kChromeUIAccessibilityHost);
135  html_source->SetUseJsonJSFormatV2();
136
137  web_ui->RegisterMessageCallback(
138      "toggleAccessibility",
139      base::Bind(&AccessibilityUI::ToggleAccessibility,
140               base::Unretained(this)));
141  web_ui->RegisterMessageCallback(
142      "toggleGlobalAccessibility",
143      base::Bind(&AccessibilityUI::ToggleGlobalAccessibility,
144               base::Unretained(this)));
145  web_ui->RegisterMessageCallback(
146      "requestAccessibilityTree",
147      base::Bind(&AccessibilityUI::RequestAccessibilityTree,
148                 base::Unretained(this)));
149
150  // Add required resources.
151  html_source->SetJsonPath("strings.js");
152  html_source->AddResourcePath("accessibility.css", IDR_ACCESSIBILITY_CSS);
153  html_source->AddResourcePath("accessibility.js", IDR_ACCESSIBILITY_JS);
154  html_source->SetDefaultResource(IDR_ACCESSIBILITY_HTML);
155  html_source->SetRequestFilter(base::Bind(&HandleRequestCallback));
156
157  BrowserContext* browser_context =
158    web_ui->GetWebContents()->GetBrowserContext();
159  WebUIDataSource::Add(browser_context, html_source);
160}
161
162AccessibilityUI::~AccessibilityUI() {
163}
164
165void AccessibilityUI::ToggleAccessibility(const base::ListValue* args) {
166  std::string process_id_str;
167  std::string route_id_str;
168  int process_id;
169  int route_id;
170  CHECK(args->GetSize() == 2);
171  CHECK(args->GetString(0, &process_id_str));
172  CHECK(args->GetString(1, &route_id_str));
173  CHECK(base::StringToInt(process_id_str,
174                          &process_id));
175  CHECK(base::StringToInt(route_id_str, &route_id));
176
177  RenderViewHost* rvh = RenderViewHost::FromID(process_id, route_id);
178  if (!rvh)
179    return;
180  RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(rvh);
181  if (!rwhi)
182    return;
183  AccessibilityMode mode = rwhi->accessibility_mode();
184  if (mode == AccessibilityModeOff)
185    rwhi->SetAccessibilityMode(AccessibilityModeComplete);
186  else
187    rwhi->SetAccessibilityMode(AccessibilityModeOff);
188}
189
190void AccessibilityUI::ToggleGlobalAccessibility(const base::ListValue* args) {
191  BrowserAccessibilityStateImpl* state =
192      BrowserAccessibilityStateImpl::GetInstance();
193  AccessibilityMode mode = state->accessibility_mode();
194  AccessibilityMode new_mode = (mode == AccessibilityModeOff
195                                ? AccessibilityModeComplete
196                                : AccessibilityModeOff);
197  state->SetAccessibilityMode(new_mode);
198}
199
200void AccessibilityUI::RequestAccessibilityTree(const base::ListValue* args) {
201  std::string process_id_str;
202  std::string route_id_str;
203  int process_id;
204  int route_id;
205  CHECK(args->GetSize() == 2);
206  CHECK(args->GetString(0, &process_id_str));
207  CHECK(args->GetString(1, &route_id_str));
208  CHECK(base::StringToInt(process_id_str, &process_id));
209  CHECK(base::StringToInt(route_id_str, &route_id));
210
211  RenderViewHost* rvh = RenderViewHost::FromID(process_id, route_id);
212  if (!rvh) {
213    scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
214    result->SetInteger(kProcessIdField, process_id);
215    result->SetInteger(kRouteIdField, route_id);
216    result->Set("error", new base::StringValue("Renderer no longer exists."));
217    web_ui()->CallJavascriptFunction("accessibility.showTree", *(result.get()));
218    return;
219  }
220
221  scoped_ptr<base::DictionaryValue> result(BuildTargetDescriptor(rvh));
222  RenderWidgetHostViewPort* host_view = static_cast<RenderWidgetHostViewPort*>(
223      WebContents::FromRenderViewHost(rvh)->GetRenderWidgetHostView());
224  if (!host_view) {
225    result->Set("error",
226                new base::StringValue("Could not get accessibility tree."));
227    web_ui()->CallJavascriptFunction("accessibility.showTree", *(result.get()));
228    return;
229  }
230  scoped_ptr<AccessibilityTreeFormatter> formatter(
231      AccessibilityTreeFormatter::Create(rvh));
232  string16 accessibility_contents_utf16;
233  BrowserAccessibilityManager* manager =
234      host_view->GetBrowserAccessibilityManager();
235  if (!manager) {
236    result->Set("error",
237                new base::StringValue("Could not get accessibility tree."));
238    web_ui()->CallJavascriptFunction("accessibility.showTree", *(result.get()));
239    return;
240  }
241  std::vector<AccessibilityTreeFormatter::Filter> filters;
242  filters.push_back(AccessibilityTreeFormatter::Filter(
243      ASCIIToUTF16("*"),
244      AccessibilityTreeFormatter::Filter::ALLOW));
245  formatter->SetFilters(filters);
246  formatter->FormatAccessibilityTree(&accessibility_contents_utf16);
247
248  result->Set("tree",
249              new base::StringValue(UTF16ToUTF8(accessibility_contents_utf16)));
250  web_ui()->CallJavascriptFunction("accessibility.showTree", *(result.get()));
251}
252
253}  // namespace content
254