Move message routing from CefBrowser to CefFrame (see issue #2498).

This change moves the SendProcessMessage method from CefBrowser to CefFrame and
adds CefBrowser parameters to OnProcessMessageReceived and
OnDraggableRegionsChanged.

The internal implementation has changed as follows:
- Frame IDs are now a 64-bit combination of the 32-bit render_process_id and
  render_routing_id values that uniquely identify a RenderFrameHost (RFH).
- CefFrameHostImpl objects are now managed by CefBrowserInfo with life span tied
  to RFH expectations. Specifically, a CefFrameHostImpl object representing a
  sub-frame will be created when a RenderFrame is created in the renderer
  process and detached when the associated RenderFrame is deleted or the
  renderer process in which it runs has died.
- The CefFrameHostImpl object representing the main frame will always be valid
  but the underlying RFH (and associated frame ID) may change over time as a
  result of cross-origin navigations. Despite these changes calling LoadURL on
  the main frame object in the browser process will always navigate as expected.
- Speculative RFHs, which may be created as a result of a cross-origin
  navigation and discarded if that navigation is not committed, are now handled
  correctly (e.g. ignored in most cases until they're committed).
- It is less likely, but still possible, to receive a CefFrame object with an
  invalid frame ID (ID < 0). This can happen in cases where a RFH has not yet
  been created for a sub-frame. For example, when OnBeforeBrowse is called
  before initiating navigation in a previously nonexisting sub-frame.

To test: All tests pass with NetworkService enabled and disabled.

libcef/renderer/frame_impl.h

@@ -10,13 +10,27 @@
 #include "include/cef_frame.h"
 #include "include/cef_v8.h"
 
-class CefBrowserImpl;
+namespace base {
+class ListValue;
+}
 
 namespace blink {
 class WebLocalFrame;
 class WebURLLoaderFactory;
 }  // namespace blink
 
+namespace IPC {
+class Message;
+}
+
+class GURL;
+
+class CefBrowserImpl;
+class CefResponseManager;
+struct CefMsg_LoadRequest_Params;
+struct Cef_Request_Params;
+struct Cef_Response_Params;
+
 // Implementation of CefFrame. CefFrameImpl objects are owned by the
 // CefBrowerImpl and will be detached when the browser is notified that the
 // associated renderer WebFrame will close.
@@ -57,23 +71,50 @@ class CefFrameImpl : public CefFrame {
   CefRefPtr<CefURLRequest> CreateURLRequest(
       CefRefPtr<CefRequest> request,
       CefRefPtr<CefURLRequestClient> client) override;
+  void SendProcessMessage(CefProcessId target_process,
+                          CefRefPtr<CefProcessMessage> message) override;
 
   // Used by CefRenderURLRequest.
   blink::WebURLLoaderFactory* GetURLLoaderFactory();
 
-  void Detach();
+  // Forwarded from CefRenderFrameObserver.
+  void OnAttached();
+  bool OnMessageReceived(const IPC::Message& message);
+  void OnDidFinishLoad();
+  void OnFocused();
+  void OnDraggableRegionsChanged();
+  void OnDetached();
 
   blink::WebLocalFrame* web_frame() const { return frame_; }
 
  private:
   void ExecuteCommand(const std::string& command);
 
+  // Avoids unnecessary string type conversions.
+  void SendProcessMessage(CefProcessId target_process,
+                          const std::string& name,
+                          base::ListValue* arguments,
+                          bool user_initiated);
+
+  // Send a message to the RenderFrame associated with this frame.
+  void Send(IPC::Message* message);
+
+  // OnMessageReceived message handlers.
+  void OnRequest(const Cef_Request_Params& params);
+  void OnResponse(const Cef_Response_Params& params);
+  void OnResponseAck(int request_id);
+  void OnDidStopLoading();
+  void OnLoadRequest(const CefMsg_LoadRequest_Params& params);
+
   CefBrowserImpl* browser_;
   blink::WebLocalFrame* frame_;
-  int64 frame_id_;
+  const int64 frame_id_;
 
   std::unique_ptr<blink::WebURLLoaderFactory> url_loader_factory_;
 
+  // Manages response registrations.
+  std::unique_ptr<CefResponseManager> response_manager_;
+
   IMPLEMENT_REFCOUNTING(CefFrameImpl);
   DISALLOW_COPY_AND_ASSIGN(CefFrameImpl);
 };