Add more of the server-side plumbing for extension APIs. Also

chrome/browser/extensions/extension_function.h

+// 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_