blob: 421df8127003c28042cf4d5c60797717ae58b4b8 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
// Copyright (c) 2009 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.
#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
#define CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
#include <string>
#include "base/values.h"
#include "base/scoped_ptr.h"
class ExtensionFunctionDispatcher;
// Base class for an extension function.
// TODO(aa): This will have to become reference counted when we introduce APIs
// that live beyond a single stack frame.
class ExtensionFunction {
public:
virtual ~ExtensionFunction() {}
void set_dispatcher(ExtensionFunctionDispatcher* dispatcher) {
dispatcher_ = dispatcher;
}
void set_args(Value* args) { args_ = args; }
void set_callback_id(int callback_id) { callback_id_ = callback_id; }
int callback_id() { return callback_id_; }
Value* result() { return result_.get(); }
const std::string& error() { return error_; }
// Whether the extension has registered a callback and is waiting for a
// response. APIs can use this to avoid doing unnecessary work in the case
// that the extension is not expecting a response.
bool has_callback() { return callback_id_ != -1; }
// Execute the API. Clients should call set_args() and set_callback_id()
// before calling this method. Derived classes should populate result_ and
// error_ before returning.
virtual void Run() = 0;
protected:
void SendResponse(bool success);
// The arguments to the API. Only non-null if argument were specfied.
Value* args_;
// The result of the API. This should be populated by the derived class before
// Run() returns.
scoped_ptr<Value> result_;
// Any detailed error from the API. This should be populated by the derived
// class before Run() returns.
std::string error_;
private:
ExtensionFunctionDispatcher* dispatcher_;
int callback_id_;
};
// A SyncExtensionFunction is an ExtensionFunction that runs synchronously
// *relative to the browser's UI thread*. Note that this has nothing to do with
// running synchronously relative to the extension process. From the extension
// process's point of view, the function is still asynchronous.
//
// This kind of function is convenient for implementing simple APIs that just
// need to interact with things on the browser UI thread.
class SyncExtensionFunction : public ExtensionFunction {
public:
// Derived classes should implement this method to do their work and return
// success/failure.
virtual bool RunImpl() = 0;
virtual void Run() {
SendResponse(RunImpl());
}
};
#endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_FUNCTION_H_
|
