[Extensions Bindings] Add APIBindingsSystem

extensions/renderer/api_bindings_system.h

+// Copyright 2016 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 EXTENSIONS_RENDERER_API_BINDINGS_SYSTEM_H_
+#define EXTENSIONS_RENDERER_API_BINDINGS_SYSTEM_H_
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "extensions/renderer/api_request_handler.h"
+#include "extensions/renderer/argument_spec.h"
+
+namespace base {
+class DictionaryValue;
+class ListValue;
+}
+
+namespace extensions {
+class APIBinding;
+class APIRequestHandler;
+
+// A class encompassing the necessary pieces to construct the JS entry points
+// for Extension APIs. Designed to be used on a single thread, but safe between
+// multiple v8::Contexts.
+class APIBindingsSystem {
+ public:
+  // TODO(devlin): We will probably want to coalesce this with the
+  // ExtensionHostMsg_Request_Params IPC struct.
+  struct Request {
+    Request();
+    ~Request();
+
+    std::string request_id;
+    std::string method_name;
+    std::unique_ptr<base::ListValue> arguments;
+  };
+
+  using GetAPISchemaMethod =
+      base::Callback<const base::DictionaryValue&(const std::string&)>;
+  using SendRequestMethod = base::Callback<void(std::unique_ptr<Request>)>;
+
+  APIBindingsSystem(const APIRequestHander::CallJSFunction& call_js,
+                    const GetAPISchemaMethod& get_api_schema,
+                    const SendRequestMethod& send_request);
+  ~APIBindingsSystem();
+
+  // Returns a new v8::Object representing the api specified by |api_name|.
+  v8::Local<v8::Object> CreateAPIInstance(const std::string& api_name,
+                                          v8::Local<v8::Context> context,
+                                          v8::Isolate* isolate);
+
+  // Responds to the request with the given |request_id|, calling the callback
+  // with |response|.
+  void CompleteRequest(const std::string& request_id,
+                       const base::ListValue& response);
+
+ private:
+  // Creates a new APIBinding for the given |api_name|.
+  std::unique_ptr<APIBinding> CreateNewAPIBinding(const std::string& api_name);
+
+  // Handles a call into an API, adds a pending request to the request_handler_,

[lazyboy, 2016/10/31 20:08:31]

nit: |request_handler_|, |send_request_|

[Devlin, 2016/10/31 22:03:36]

Done.

+  // and calls send_request_.
+  void OnAPICall(const std::string& name,
+                 std::unique_ptr<base::ListValue> arguments,
+                 v8::Isolate* isolate,
+                 v8::Local<v8::Context> context,
+                 v8::Local<v8::Function> callback);
+
+  // The map of cached API reference types.
+  ArgumentSpec::RefMap type_reference_map_;
+
+  // The request handler associated with the system.
+  APIRequestHandler request_handler_;
+
+  // A map from api_name -> APIBinding for constructed APIs. APIBindings are
+  // created lazily.
+  std::map<std::string, std::unique_ptr<APIBinding>> api_bindings_;
+
+  // The method to retrieve the DictionaryValue describing a given extension
+  // API. Curried in for testing purposes so we can use fake APIs.
+  GetAPISchemaMethod get_api_schema_;
+
+  // The method to call when a new API call is triggered. Curried in for testing
+  // purposes. Typically, this would send an IPC to the browser to begin the
+  // function work.
+  SendRequestMethod send_request_;
+
+  DISALLOW_COPY_AND_ASSIGN(APIBindingsSystem);
+};
+
+}  // namespace
+
+#endif  // EXTENSIONS_RENDERER_API_BINDINGS_SYSTEM_H_