[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 43 matching lines @@
 
 namespace ui {
 struct SelectedFileInfo;
 }
 
 namespace content {
 
 class BrowserMediaPlayerManager;
 class ChildProcessSecurityPolicyImpl;
 class PageState;
-class RenderFrameHostImpl;
 class RenderWidgetHostDelegate;
 class SessionStorageNamespace;
 class SessionStorageNamespaceImpl;
 class TestRenderViewHost;
 struct ContextMenuParams;
 struct FileChooserParams;
 struct Referrer;
 struct ShowDesktopNotificationHostMsgParams;
 
 #if defined(COMPILER_MSVC)
@@ skipping 145 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;
   }
 
+  // Keep track of which RenderFrameHosts are using this RenderViewHost.  When
+  // the number drops to zero, we call Shutdown.  This cannot use frame_ids,
+  // since the RenderFrameHost may outlive the process (or may go away before
+  // the process and frame_id are created).
+  void RegisterRenderFrameHost(RenderFrameHostImpl* render_frame_host);
+  void UnregisterRenderFrameHost(RenderFrameHostImpl* render_frame_host);
+
+  // 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 string16& frame_name,
                                 int opener_route_id,
                                 int32 max_page_id);
 
@@ skipping 181 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 27 matching lines @@
   bool CanCommitURL(const GURL& url);
 
   // Checks that the given renderer can request |url|, if not it sets it to
   // about:blank.
   // empty_allowed must be set to false for navigations for security reasons.
   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.
-  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,
                                          const GURL& url);
 
@@ skipping 103 matching lines @@
   void OnCancelDesktopNotification(int notification_id);
   void OnRunFileChooser(const FileChooserParams& params);
   void OnDidAccessInitialDocument();
   void OnDomOperationResponse(const std::string& json_string,
                               int automation_id);
 
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   void OnShowPopup(const ViewHostMsg_ShowPopup_Params& params);
 #endif
 
-  // TODO(nasko): Remove this accessor once RenderFrameHost moves into the frame
-  // tree.
-  RenderFrameHostImpl* main_render_frame_host() const {
-    return main_render_frame_host_.get();
-  }
-
  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;
 
-  // All RenderViewHosts must have a RenderFrameHost for its main frame.
-  // Currently the RenderFrameHost is created in lock step on construction
-  // and a pointer to the main frame is given to the FrameTreeNode
-  // when the RenderViewHost commits (see AttachToFrameTree()).
-  //
-  // TODO(ajwong): Make this reference non-owning. The root FrameTreeNode of
-  // the FrameTree should be responsible for owning the main frame's
-  // RenderFrameHost.
-  scoped_ptr<RenderFrameHostImpl> main_render_frame_host_;
-
   // 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_;
 
+  // A list of RenderFrameHosts depending on this RenderViewHost.  When the list
+  // size goes to zero, this RenderViewHost is shut down.
+  std::set<RenderFrameHostImpl*> rfh_list_;
+
+  // 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).
-  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.
   // When either this value or is_waiting_for_unload_ack_ is true, the value of
@@ skipping 44 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_