Extract ExtensionRequestSender from SchemaGeneratedBindings.

chrome/renderer/extensions/extension_request_sender.h

+// Copyright (c) 2012 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_RENDERER_EXTENSIONS_EXTENSION_REQUEST_SENDER_H_
+#define CHROME_RENDERER_EXTENSIONS_EXTENSION_REQUEST_SENDER_H_
+#pragma once
+
+#include <string>
+#include <map>
+
+#include "base/memory/linked_ptr.h"
+#include "v8/include/v8.h"
+
+class ChromeV8ContextSet;
+class ExtensionDispatcher;
+
+namespace base {
+class ListValue;
+}
+
+struct PendingRequest;
+
+// Calls a named extension API function in the extension host and routes the
+// response back to the caller.

[not at google - send to devlin, 2012/03/30 03:14:31]

This reads more like the documentation that would be on a method. Could you
just... tweak it slightly?

[koz (OOO until 15th September), 2012/04/03 00:15:17]

Done.

+class ExtensionRequestSender {
+ public:
+  explicit ExtensionRequestSender(ExtensionDispatcher* extension_dispatcher,
+                                  ChromeV8ContextSet* context_set);
+  ~ExtensionRequestSender();
+
+  // Makes a call to the API function |name| that is to be handled by the
+  // extension host. The response to this request will be received in
+  // HandleResponse().
+  // TODO(koz): Remove |request_id| and generate that internally.
+  void StartRequest(const std::string& name,

[not at google - send to devlin, 2012/03/30 03:14:31]

Looking at the implementation of this method it seems strange to me that we just
drop various failure conditions on the floor. This was the current behaviour I
suppose, but still. Perhaps this can return a success value or something to say
whether a request was actually made? Not that we necessarily need to do anything
about it in this class, let the caller deal with that (not in this patch), but
at least it's there.

[koz (OOO until 15th September), 2012/04/03 00:15:17]

Perhaps the caller doesn't care? Maybe the silent fail cases are only hit in
shutdown or something. Either way, I'm leery of adding a return for hypothetical
use cases.

+                    int request_id,
+                    bool has_callback,
+                    bool for_io_thread,
+                    base::ListValue* value_args);
+
+  // Handles responses from the extension host to calls made by StartRequest().
+  void HandleResponse(int request_id,

[not at google - send to devlin, 2012/03/30 03:14:31]

"OnResponse" feels like a better name, it implies the relationship between
StartRequest and this method more accurately, makes the role of this class a bit
more clear... IMO...

Don't feel strongly though. I guess the JS side uses "handleResponse" and it's
too much effort to go and change that.

[koz (OOO until 15th September), 2012/04/03 00:15:17]

Yeah, it doesn't seem worth the change. HandleResponse() vs OnResponse() I think
are basically equivalent.

+                      bool success,
+                      const std::string& response,
+                      const std::string& error);
+
+
+ private:
+  typedef std::map<int, linked_ptr<PendingRequest> > PendingRequestMap;
+
+  void InsertRequest(int request_id, PendingRequest* pending_request);
+  PendingRequest* GetPendingRequest(int request_id);
+  void RemoveRequest(int request_id);
+
+  ExtensionDispatcher* extension_dispatcher_;
+  PendingRequestMap pending_requests_;
+  ChromeV8ContextSet* context_set_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionRequestSender);
+};
+
+#endif  // CHROME_RENDERER_EXTENSIONS_EXTENSION_REQUEST_SENDER_H_