[DRAFT] Create RenderFrameHostManager.

content/browser/renderer_host/render_view_host_impl.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 CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_IMPL_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 209 matching lines @@
                                          float y) OVERRIDE;
   virtual void RequestFindMatchRects(int current_version) OVERRIDE;
   virtual void DisableFullscreenEncryptedMediaPlayback() OVERRIDE;
 #endif
 
   void set_delegate(RenderViewHostDelegate* d) {
     CHECK(d);  // http://crbug.com/82827
     delegate_ = d;
   }
 
+  // Map renderer-specific frame IDs to browser-global FrameTreeNode IDs.
+  // TODO(creis): Call Unregister.
+  void RegisterFrameID(int64 frame_id, int64 frame_tree_node_id);
+  void UnregisterFrameID(int64 frame_id);
+  bool HasFrameID(int64 frame_id) const;
+  int64 GetFrameTreeNodeID(int64 frame_id);
+  int64 GetFrameIDForTesting(int64 frame_tree_node_id) const;
+
   // Set up the RenderView child process. Virtual because it is overridden by
   // TestRenderViewHost. If the |frame_name| parameter is non-empty, it is used
   // as the name of the new top-level frame.
   // The |opener_route_id| parameter indicates which RenderView created this
   // (MSG_ROUTING_NONE if none). If |max_page_id| is larger than -1, the
   // RenderView is told to start issuing page IDs at |max_page_id| + 1.
   virtual bool CreateRenderView(const base::string16& frame_name,
                                 int opener_route_id,
                                 int32 max_page_id);
 
@@ skipping 182 matching lines @@
 
   // User rotated the screen. Calls the "onorientationchange" Javascript hook.
   void SendOrientationChangeEvent(int orientation);
 
   // Sets a bit indicating whether the RenderView is responsible for displaying
   // a subframe in a different process from its parent page.
   void set_is_subframe(bool is_subframe) {
     is_subframe_ = is_subframe;
   }
 
-  // TODO(creis): Remove this when we replace frame IDs with RenderFrameHost
-  // routing IDs.
-  int64 main_frame_id() const {
-    return main_frame_id_;
-  }
-
   // Set the opener to null in the renderer process.
   void DisownOpener();
 
   // Turn on accessibility testing. The given callback will be run
   // every time an accessibility notification is received from the
   // renderer process, and the accessibility tree it sent can be
   // retrieved using accessibility_tree_for_testing().
   void SetAccessibilityCallbackForTesting(
       const base::Callback<void(blink::WebAXEvent)>& callback);
 
@@ skipping 32 matching lines @@
   static void FilterURL(ChildProcessSecurityPolicyImpl* policy,
                         const RenderProcessHost* process,
                         bool empty_allowed,
                         GURL* url);
 
   // Update the FrameTree to use this RenderViewHost's main frame
   // RenderFrameHost. Called when the RenderViewHost is committed.
   //
   // TODO(ajwong): Remove once RenderViewHost no longer owns the main frame
   // RenderFrameHost.
+  // TODO(creis): Remove this in favor of FrameTree::ResetForMainFrameSwap.
   void AttachToFrameTree();
 
   // The following IPC handlers are public so RenderFrameHost can call them,
   // while we transition the code to not use RenderViewHost.
   //
   // TODO(nasko): Remove those methods once we are done moving navigation
   // into RenderFrameHost.
   void OnDidStartProvisionalLoadForFrame(int64 frame_id,
                                          int64 parent_frame_id,
                                          bool main_frame,
@@ skipping 111 matching lines @@
 
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   void OnShowPopup(const ViewHostMsg_ShowPopup_Params& params);
 #endif
 
  private:
   friend class TestRenderViewHost;
   FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, BasicRenderFrameHost);
   FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, RoutingIdSane);
 
+  typedef base::hash_map<int64, int64> FrameIDMap;
+
   // Sets whether this RenderViewHost is swapped out in favor of another,
   // and clears any waiting state that is no longer relevant.
   void SetSwappedOut(bool is_swapped_out);
 
   bool CanAccessFilesOfPageState(const PageState& state) const;
 
   // Our delegate, which wants to know about changes in the RenderView.
   RenderViewHostDelegate* delegate_;
 
   // The SiteInstance associated with this RenderViewHost.  All pages drawn
   // in this RenderViewHost are part of this SiteInstance.  Should not change
   // over time.
   scoped_refptr<SiteInstanceImpl> instance_;
 
+  // Map of renderer-specific frame IDs to browser-global FrameTreeNode IDs.
+  FrameIDMap frame_id_map_;
+
   // true if we are currently waiting for a response for drag context
   // information.
   bool waiting_for_drag_context_response_;
 
   // A bitwise OR of bindings types that have been enabled for this RenderView.
   // See BindingsPolicy for details.
   int enabled_bindings_;
 
   // Whether we should buffer outgoing Navigate messages rather than sending
   // them.  This will be true when a RenderViewHost is created for a cross-site
@@ skipping 14 matching lines @@
   bool has_accessed_initial_document_;
 
   // Whether this RenderViewHost is currently swapped out, such that the view is
   // being rendered by another process.
   bool is_swapped_out_;
 
   // Whether this RenderView is responsible for displaying a subframe in a
   // different process from its parent page.
   bool is_subframe_;
 
-  // The frame id of the main (top level) frame. This value is set on the
-  // initial navigation of a RenderView and reset when the RenderView's
-  // process is terminated (in RenderProcessGone).
-  // TODO(creis): Remove this when we switch to routing IDs for frames.
-  int64 main_frame_id_;
-
   // Routing ID for the main frame's RenderFrameHost.
+  // TODO(creis): Does this need to be updated on a crash?
   int main_frame_routing_id_;
 
   // If we were asked to RunModal, then this will hold the reply_msg that we
   // must return to the renderer to unblock it.
   IPC::Message* run_modal_reply_msg_;
   // This will hold the routing id of the RenderView that opened us.
   int run_modal_opener_id_;
 
   // Set to true when there is a pending ViewMsg_ShouldClose message.  This
   // ensures we don't spam the renderer with multiple beforeunload requests.
@@ skipping 48 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostImpl);
 };
 
 #if defined(COMPILER_MSVC)
 #pragma warning(pop)
 #endif
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_VIEW_HOST_IMPL_H_