1// Copyright (c) 2012 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 "chrome/browser/automation/automation_provider_json.h"
6
7#include "base/json/json_writer.h"
8#include "base/json/string_escape.h"
9#include "base/values.h"
10#include "chrome/browser/autocomplete/autocomplete_match.h"
11#include "chrome/browser/automation/automation_provider.h"
12#include "chrome/browser/automation/automation_util.h"
13#include "chrome/browser/extensions/extension_service.h"
14#include "chrome/browser/extensions/extension_system.h"
15#include "chrome/browser/profiles/profile.h"
16#include "chrome/common/automation_id.h"
17#include "chrome/common/automation_messages.h"
18#include "chrome/common/extensions/extension.h"
19#include "content/public/browser/web_contents.h"
20
21using automation::Error;
22using automation::ErrorCode;
23using content::WebContents;
24
25AutomationJSONReply::AutomationJSONReply(AutomationProvider* provider,
26                                         IPC::Message* reply_message)
27  : provider_(provider),
28    message_(reply_message) {
29}
30
31AutomationJSONReply::~AutomationJSONReply() {
32  DCHECK(!message_) << "JSON automation request not replied!";
33}
34
35void AutomationJSONReply::SendSuccess(const Value* value) {
36  DCHECK(message_) << "Resending reply for JSON automation request";
37  std::string json_string = "{}";
38  if (value)
39    base::JSONWriter::Write(value, &json_string);
40  AutomationMsg_SendJSONRequest::WriteReplyParams(
41      message_, json_string, true);
42  provider_->Send(message_);
43  message_ = NULL;
44}
45
46void AutomationJSONReply::SendError(const std::string& error_message) {
47  SendError(Error(error_message));
48}
49
50void AutomationJSONReply::SendErrorCode(ErrorCode code) {
51  SendError(Error(code));
52}
53
54void AutomationJSONReply::SendError(const Error& error) {
55  DCHECK(message_) << "Resending reply for JSON automation request";
56
57  base::DictionaryValue dict;
58  dict.SetString("error", error.message());
59  dict.SetInteger("code", error.code());
60  std::string json;
61  base::JSONWriter::Write(&dict, &json);
62
63  AutomationMsg_SendJSONRequest::WriteReplyParams(message_, json, false);
64  provider_->Send(message_);
65  message_ = NULL;
66}
67
68bool GetBrowserFromJSONArgs(
69    DictionaryValue* args,
70    Browser** browser,
71    std::string* error) {
72  if (args->HasKey("auto_id")) {
73    AutomationId id;
74    if (!GetAutomationIdFromJSONArgs(args, "auto_id", &id, error))
75      return false;
76    WebContents* tab;
77    if (!automation_util::GetTabForId(id, &tab)) {
78      *error = "'auto_id' does not refer to an open tab";
79      return false;
80    }
81    Browser* container = automation_util::GetBrowserForTab(tab);
82    if (!container) {
83      *error = "tab does not belong to an open browser";
84      return false;
85    }
86    *browser = container;
87  } else {
88    int browser_index;
89    if (!args->GetInteger("windex", &browser_index)) {
90      *error = "'windex' missing or invalid";
91      return false;
92    }
93    *browser = automation_util::GetBrowserAt(browser_index);
94    if (!*browser) {
95      *error = "Cannot locate browser from given index";
96      return false;
97    }
98  }
99  return true;
100}
101
102bool GetTabFromJSONArgs(
103    DictionaryValue* args,
104    WebContents** tab,
105    std::string* error) {
106  if (args->HasKey("auto_id")) {
107    AutomationId id;
108    if (!GetAutomationIdFromJSONArgs(args, "auto_id", &id, error))
109      return false;
110    if (!automation_util::GetTabForId(id, tab)) {
111      *error = "'auto_id' does not refer to an open tab";
112      return false;
113    }
114  } else {
115    int browser_index, tab_index;
116    if (!args->GetInteger("windex", &browser_index)) {
117      *error = "'windex' missing or invalid";
118      return false;
119    }
120    if (!args->GetInteger("tab_index", &tab_index)) {
121      *error = "'tab_index' missing or invalid";
122      return false;
123    }
124    *tab = automation_util::GetWebContentsAt(browser_index, tab_index);
125    if (!*tab) {
126      *error = "Cannot locate tab from given indices";
127      return false;
128    }
129  }
130  return true;
131}
132
133bool GetBrowserAndTabFromJSONArgs(
134    DictionaryValue* args,
135    Browser** browser,
136    WebContents** tab,
137    std::string* error) {
138  return GetBrowserFromJSONArgs(args, browser, error) &&
139         GetTabFromJSONArgs(args, tab, error);
140}
141
142bool GetAutomationIdFromJSONArgs(
143    DictionaryValue* args,
144    const std::string& key,
145    AutomationId* id,
146    std::string* error) {
147  Value* id_value;
148  if (!args->Get(key, &id_value)) {
149    *error = base::StringPrintf("Missing parameter '%s'", key.c_str());
150    return false;
151  }
152  return AutomationId::FromValue(id_value, id, error);
153}
154
155bool GetRenderViewFromJSONArgs(
156    DictionaryValue* args,
157    Profile* profile,
158    content::RenderViewHost** rvh,
159    std::string* error) {
160  Value* id_value;
161  if (args->Get("auto_id", &id_value)) {
162    AutomationId id;
163    if (!AutomationId::FromValue(id_value, &id, error))
164      return false;
165    if (!automation_util::GetRenderViewForId(id, profile, rvh)) {
166      *error = "ID does not correspond to an open view";
167      return false;
168    }
169  } else {
170    // If the render view id is not specified, check for browser/tab indices.
171    WebContents* tab = NULL;
172    if (!GetTabFromJSONArgs(args, &tab, error))
173      return false;
174    *rvh = tab->GetRenderViewHost();
175  }
176  return true;
177}
178
179namespace {
180
181bool GetExtensionFromJSONArgsHelper(
182    base::DictionaryValue* args,
183    const std::string& key,
184    Profile* profile,
185    bool include_disabled,
186    const extensions::Extension** extension,
187    std::string* error) {
188  std::string id;
189  if (!args->GetString(key, &id)) {
190    *error = base::StringPrintf("Missing or invalid key: %s", key.c_str());
191    return false;
192  }
193  ExtensionService* service = extensions::ExtensionSystem::Get(profile)->
194      extension_service();
195  if (!service) {
196    *error = "No extensions service.";
197    return false;
198  }
199  if (!service->GetInstalledExtension(id)) {
200    // The extension ID does not correspond to any extension, whether crashed
201    // or not.
202    *error = base::StringPrintf("Extension %s is not installed.",
203                                id.c_str());
204    return false;
205  }
206  const extensions::Extension* installed_extension =
207      service->GetExtensionById(id, include_disabled);
208  if (!installed_extension) {
209    *error = "Extension is disabled or has crashed.";
210    return false;
211  }
212  *extension = installed_extension;
213  return true;
214}
215
216}  // namespace
217
218bool GetExtensionFromJSONArgs(
219    base::DictionaryValue* args,
220    const std::string& key,
221    Profile* profile,
222    const extensions::Extension** extension,
223    std::string* error) {
224  return GetExtensionFromJSONArgsHelper(
225      args, key, profile, true /* include_disabled */, extension, error);
226}
227
228bool GetEnabledExtensionFromJSONArgs(
229    base::DictionaryValue* args,
230    const std::string& key,
231    Profile* profile,
232    const extensions::Extension** extension,
233    std::string* error) {
234  return GetExtensionFromJSONArgsHelper(
235      args, key, profile, false /* include_disabled */, extension, error);
236}
237