1// Copyright 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 "extensions/browser/extension_function.h"
6
7#include "base/logging.h"
8#include "content/public/browser/notification_source.h"
9#include "content/public/browser/notification_types.h"
10#include "content/public/browser/render_frame_host.h"
11#include "content/public/browser/render_view_host.h"
12#include "content/public/browser/web_contents.h"
13#include "content/public/browser/web_contents_observer.h"
14#include "extensions/browser/extension_function_dispatcher.h"
15#include "extensions/browser/extension_message_filter.h"
16#include "extensions/common/error_utils.h"
17#include "extensions/common/extension_api.h"
18#include "extensions/common/extension_messages.h"
19
20using content::BrowserThread;
21using content::RenderViewHost;
22using content::WebContents;
23using extensions::ErrorUtils;
24using extensions::ExtensionAPI;
25using extensions::Feature;
26
27namespace {
28
29class ArgumentListResponseValue
30    : public ExtensionFunction::ResponseValueObject {
31 public:
32  ArgumentListResponseValue(const std::string& function_name,
33                            const char* title,
34                            ExtensionFunction* function,
35                            scoped_ptr<base::ListValue> result)
36      : function_name_(function_name), title_(title) {
37    if (function->GetResultList()) {
38      DCHECK_EQ(function->GetResultList(), result.get())
39          << "The result set on this function (" << function_name_ << ") "
40          << "either by calling SetResult() or directly modifying |result_| is "
41          << "different to the one passed to " << title_ << "(). "
42          << "The best way to fix this problem is to exclusively use " << title_
43          << "(). SetResult() and |result_| are deprecated.";
44    } else {
45      function->SetResultList(result.Pass());
46    }
47    // It would be nice to DCHECK(error.empty()) but some legacy extension
48    // function implementations... I'm looking at chrome.input.ime... do this
49    // for some reason.
50  }
51
52  virtual ~ArgumentListResponseValue() {}
53
54  virtual bool Apply() OVERRIDE { return true; }
55
56 private:
57  std::string function_name_;
58  const char* title_;
59};
60
61class ErrorResponseValue : public ExtensionFunction::ResponseValueObject {
62 public:
63  ErrorResponseValue(ExtensionFunction* function, const std::string& error) {
64    // It would be nice to DCHECK(!error.empty()) but too many legacy extension
65    // function implementations don't set error but signal failure.
66    function->SetError(error);
67  }
68
69  virtual ~ErrorResponseValue() {}
70
71  virtual bool Apply() OVERRIDE { return false; }
72};
73
74class BadMessageResponseValue : public ExtensionFunction::ResponseValueObject {
75 public:
76  explicit BadMessageResponseValue(ExtensionFunction* function) {
77    function->set_bad_message(true);
78    NOTREACHED() << function->name() << ": bad message";
79  }
80
81  virtual ~BadMessageResponseValue() {}
82
83  virtual bool Apply() OVERRIDE { return false; }
84};
85
86class RespondNowAction : public ExtensionFunction::ResponseActionObject {
87 public:
88  typedef base::Callback<void(bool)> SendResponseCallback;
89  RespondNowAction(ExtensionFunction::ResponseValue result,
90                   const SendResponseCallback& send_response)
91      : result_(result.Pass()), send_response_(send_response) {}
92  virtual ~RespondNowAction() {}
93
94  virtual void Execute() OVERRIDE { send_response_.Run(result_->Apply()); }
95
96 private:
97  ExtensionFunction::ResponseValue result_;
98  SendResponseCallback send_response_;
99};
100
101class RespondLaterAction : public ExtensionFunction::ResponseActionObject {
102 public:
103  virtual ~RespondLaterAction() {}
104
105  virtual void Execute() OVERRIDE {}
106};
107
108}  // namespace
109
110// static
111void ExtensionFunctionDeleteTraits::Destruct(const ExtensionFunction* x) {
112  x->Destruct();
113}
114
115// Helper class to track the lifetime of ExtensionFunction's RenderViewHost or
116// RenderFrameHost  pointer and NULL it out when it dies. It also allows us to
117// filter IPC messages coming from the RenderViewHost/RenderFrameHost.
118class UIThreadExtensionFunction::RenderHostTracker
119    : public content::WebContentsObserver {
120 public:
121  explicit RenderHostTracker(UIThreadExtensionFunction* function)
122      : content::WebContentsObserver(
123            function->render_view_host() ?
124                WebContents::FromRenderViewHost(function->render_view_host()) :
125                WebContents::FromRenderFrameHost(
126                    function->render_frame_host())),
127        function_(function) {
128  }
129
130 private:
131  // content::WebContentsObserver:
132  virtual void RenderViewDeleted(
133      content::RenderViewHost* render_view_host) OVERRIDE {
134    if (render_view_host != function_->render_view_host())
135      return;
136
137    function_->SetRenderViewHost(NULL);
138  }
139  virtual void RenderFrameDeleted(
140      content::RenderFrameHost* render_frame_host) OVERRIDE {
141    if (render_frame_host != function_->render_frame_host())
142      return;
143
144    function_->SetRenderFrameHost(NULL);
145  }
146
147  virtual bool OnMessageReceived(
148      const IPC::Message& message,
149      content::RenderFrameHost* render_frame_host) OVERRIDE {
150    DCHECK(render_frame_host);
151    if (render_frame_host == function_->render_frame_host())
152      return function_->OnMessageReceived(message);
153    else
154      return false;
155  }
156
157  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
158    return function_->OnMessageReceived(message);
159  }
160
161  UIThreadExtensionFunction* function_;
162
163  DISALLOW_COPY_AND_ASSIGN(RenderHostTracker);
164};
165
166ExtensionFunction::ExtensionFunction()
167    : request_id_(-1),
168      profile_id_(NULL),
169      has_callback_(false),
170      include_incognito_(false),
171      user_gesture_(false),
172      bad_message_(false),
173      histogram_value_(extensions::functions::UNKNOWN),
174      source_tab_id_(-1),
175      source_context_type_(Feature::UNSPECIFIED_CONTEXT) {
176}
177
178ExtensionFunction::~ExtensionFunction() {
179}
180
181UIThreadExtensionFunction* ExtensionFunction::AsUIThreadExtensionFunction() {
182  return NULL;
183}
184
185IOThreadExtensionFunction* ExtensionFunction::AsIOThreadExtensionFunction() {
186  return NULL;
187}
188
189bool ExtensionFunction::HasPermission() {
190  Feature::Availability availability =
191      ExtensionAPI::GetSharedInstance()->IsAvailable(
192          name_, extension_.get(), source_context_type_, source_url());
193  return availability.is_available();
194}
195
196void ExtensionFunction::OnQuotaExceeded(const std::string& violation_error) {
197  error_ = violation_error;
198  SendResponse(false);
199}
200
201void ExtensionFunction::SetArgs(const base::ListValue* args) {
202  DCHECK(!args_.get());  // Should only be called once.
203  args_.reset(args->DeepCopy());
204}
205
206void ExtensionFunction::SetResult(base::Value* result) {
207  results_.reset(new base::ListValue());
208  results_->Append(result);
209}
210
211void ExtensionFunction::SetResultList(scoped_ptr<base::ListValue> results) {
212  results_ = results.Pass();
213}
214
215const base::ListValue* ExtensionFunction::GetResultList() const {
216  return results_.get();
217}
218
219std::string ExtensionFunction::GetError() const {
220  return error_;
221}
222
223void ExtensionFunction::SetError(const std::string& error) {
224  error_ = error;
225}
226
227ExtensionFunction::ResponseValue ExtensionFunction::NoArguments() {
228  return ResponseValue(new ArgumentListResponseValue(
229      name(), "NoArguments", this, make_scoped_ptr(new base::ListValue())));
230}
231
232ExtensionFunction::ResponseValue ExtensionFunction::OneArgument(
233    base::Value* arg) {
234  scoped_ptr<base::ListValue> args(new base::ListValue());
235  args->Append(arg);
236  return ResponseValue(
237      new ArgumentListResponseValue(name(), "OneArgument", this, args.Pass()));
238}
239
240ExtensionFunction::ResponseValue ExtensionFunction::TwoArguments(
241    base::Value* arg1,
242    base::Value* arg2) {
243  scoped_ptr<base::ListValue> args(new base::ListValue());
244  args->Append(arg1);
245  args->Append(arg2);
246  return ResponseValue(
247      new ArgumentListResponseValue(name(), "TwoArguments", this, args.Pass()));
248}
249
250ExtensionFunction::ResponseValue ExtensionFunction::ArgumentList(
251    scoped_ptr<base::ListValue> args) {
252  return ResponseValue(
253      new ArgumentListResponseValue(name(), "ArgumentList", this, args.Pass()));
254}
255
256ExtensionFunction::ResponseValue ExtensionFunction::Error(
257    const std::string& error) {
258  return ResponseValue(new ErrorResponseValue(this, error));
259}
260
261ExtensionFunction::ResponseValue ExtensionFunction::Error(
262    const std::string& format,
263    const std::string& s1) {
264  return ResponseValue(
265      new ErrorResponseValue(this, ErrorUtils::FormatErrorMessage(format, s1)));
266}
267
268ExtensionFunction::ResponseValue ExtensionFunction::Error(
269    const std::string& format,
270    const std::string& s1,
271    const std::string& s2) {
272  return ResponseValue(new ErrorResponseValue(
273      this, ErrorUtils::FormatErrorMessage(format, s1, s2)));
274}
275
276ExtensionFunction::ResponseValue ExtensionFunction::Error(
277    const std::string& format,
278    const std::string& s1,
279    const std::string& s2,
280    const std::string& s3) {
281  return ResponseValue(new ErrorResponseValue(
282      this, ErrorUtils::FormatErrorMessage(format, s1, s2, s3)));
283}
284
285ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() {
286  return ResponseValue(new BadMessageResponseValue(this));
287}
288
289ExtensionFunction::ResponseAction ExtensionFunction::RespondNow(
290    ResponseValue result) {
291  return ResponseAction(new RespondNowAction(
292      result.Pass(), base::Bind(&ExtensionFunction::SendResponse, this)));
293}
294
295ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() {
296  return ResponseAction(new RespondLaterAction());
297}
298
299// static
300ExtensionFunction::ResponseAction ExtensionFunction::ValidationFailure(
301    ExtensionFunction* function) {
302  return function->RespondNow(function->BadMessage());
303}
304
305void ExtensionFunction::Respond(ResponseValue result) {
306  SendResponse(result->Apply());
307}
308
309bool ExtensionFunction::ShouldSkipQuotaLimiting() const {
310  return false;
311}
312
313bool ExtensionFunction::HasOptionalArgument(size_t index) {
314  base::Value* value;
315  return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL);
316}
317
318void ExtensionFunction::SendResponseImpl(bool success) {
319  DCHECK(!response_callback_.is_null());
320
321  ResponseType type = success ? SUCCEEDED : FAILED;
322  if (bad_message_) {
323    type = BAD_MESSAGE;
324    LOG(ERROR) << "Bad extension message " << name_;
325  }
326
327  // If results were never set, we send an empty argument list.
328  if (!results_)
329    results_.reset(new base::ListValue());
330
331  response_callback_.Run(type, *results_, GetError());
332}
333
334void ExtensionFunction::OnRespondingLater(ResponseValue value) {
335  SendResponse(value->Apply());
336}
337
338UIThreadExtensionFunction::UIThreadExtensionFunction()
339    : render_view_host_(NULL),
340      render_frame_host_(NULL),
341      context_(NULL),
342      delegate_(NULL) {
343}
344
345UIThreadExtensionFunction::~UIThreadExtensionFunction() {
346  if (dispatcher() && render_view_host())
347    dispatcher()->OnExtensionFunctionCompleted(extension());
348}
349
350UIThreadExtensionFunction*
351UIThreadExtensionFunction::AsUIThreadExtensionFunction() {
352  return this;
353}
354
355bool UIThreadExtensionFunction::OnMessageReceived(const IPC::Message& message) {
356  return false;
357}
358
359void UIThreadExtensionFunction::Destruct() const {
360  BrowserThread::DeleteOnUIThread::Destruct(this);
361}
362
363void UIThreadExtensionFunction::SetRenderViewHost(
364    RenderViewHost* render_view_host) {
365  DCHECK(!render_frame_host_);
366  render_view_host_ = render_view_host;
367  tracker_.reset(render_view_host ? new RenderHostTracker(this) : NULL);
368}
369
370void UIThreadExtensionFunction::SetRenderFrameHost(
371    content::RenderFrameHost* render_frame_host) {
372  DCHECK(!render_view_host_);
373  render_frame_host_ = render_frame_host;
374  tracker_.reset(render_frame_host ? new RenderHostTracker(this) : NULL);
375}
376
377content::WebContents* UIThreadExtensionFunction::GetAssociatedWebContents() {
378  content::WebContents* web_contents = NULL;
379  if (dispatcher())
380    web_contents = dispatcher()->delegate()->GetAssociatedWebContents();
381
382  return web_contents;
383}
384
385void UIThreadExtensionFunction::SendResponse(bool success) {
386  if (delegate_)
387    delegate_->OnSendResponse(this, success, bad_message_);
388  else
389    SendResponseImpl(success);
390
391  if (!transferred_blob_uuids_.empty()) {
392    DCHECK(!delegate_) << "Blob transfer not supported with test delegate.";
393    GetIPCSender()->Send(
394        new ExtensionMsg_TransferBlobs(transferred_blob_uuids_));
395  }
396}
397
398void UIThreadExtensionFunction::SetTransferredBlobUUIDs(
399    const std::vector<std::string>& blob_uuids) {
400  DCHECK(transferred_blob_uuids_.empty());  // Should only be called once.
401  transferred_blob_uuids_ = blob_uuids;
402}
403
404void UIThreadExtensionFunction::WriteToConsole(
405    content::ConsoleMessageLevel level,
406    const std::string& message) {
407  GetIPCSender()->Send(
408      new ExtensionMsg_AddMessageToConsole(GetRoutingID(), level, message));
409}
410
411IPC::Sender* UIThreadExtensionFunction::GetIPCSender() {
412  if (render_view_host_)
413    return render_view_host_;
414  else
415    return render_frame_host_;
416}
417
418int UIThreadExtensionFunction::GetRoutingID() {
419  if (render_view_host_)
420    return render_view_host_->GetRoutingID();
421  else
422    return render_frame_host_->GetRoutingID();
423}
424
425IOThreadExtensionFunction::IOThreadExtensionFunction()
426    : routing_id_(MSG_ROUTING_NONE) {
427}
428
429IOThreadExtensionFunction::~IOThreadExtensionFunction() {
430}
431
432IOThreadExtensionFunction*
433IOThreadExtensionFunction::AsIOThreadExtensionFunction() {
434  return this;
435}
436
437void IOThreadExtensionFunction::Destruct() const {
438  BrowserThread::DeleteOnIOThread::Destruct(this);
439}
440
441void IOThreadExtensionFunction::SendResponse(bool success) {
442  SendResponseImpl(success);
443}
444
445AsyncExtensionFunction::AsyncExtensionFunction() {
446}
447
448AsyncExtensionFunction::~AsyncExtensionFunction() {
449}
450
451ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() {
452  return RunAsync() ? RespondLater() : RespondNow(Error(error_));
453}
454
455// static
456bool AsyncExtensionFunction::ValidationFailure(
457    AsyncExtensionFunction* function) {
458  return false;
459}
460
461SyncExtensionFunction::SyncExtensionFunction() {
462}
463
464SyncExtensionFunction::~SyncExtensionFunction() {
465}
466
467ExtensionFunction::ResponseAction SyncExtensionFunction::Run() {
468  return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_));
469}
470
471// static
472bool SyncExtensionFunction::ValidationFailure(SyncExtensionFunction* function) {
473  return false;
474}
475
476SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() {
477}
478
479SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() {
480}
481
482ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
483  return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_));
484}
485
486// static
487bool SyncIOThreadExtensionFunction::ValidationFailure(
488    SyncIOThreadExtensionFunction* function) {
489  return false;
490}
491