Support frame tree propagation between renderers in the same browsing instance.

content/renderer/render_view_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_RENDERER_RENDER_VIEW_IMPL_H_
 #define CONTENT_RENDERER_RENDER_VIEW_IMPL_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/id_map.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/timer.h"
+#include "base/values.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
 #include "content/common/edit_command.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/navigation_gesture.h"
 #include "content/common/view_message_enums.h"
 #include "content/public/common/javascript_message_type.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/renderer_preferences.h"
@@ skipping 504 matching lines @@
       WebKit::WebFrame* frame,
       WebKit::WebMediaPlayerClient* client);
   virtual WebKit::WebMediaPlayer* createMediaPlayer(
       WebKit::WebFrame* frame,
       const WebKit::WebURL& url,
       WebKit::WebMediaPlayerClient* client);
   virtual WebKit::WebApplicationCacheHost* createApplicationCacheHost(
       WebKit::WebFrame* frame,
       WebKit::WebApplicationCacheHostClient* client);
   virtual WebKit::WebCookieJar* cookieJar(WebKit::WebFrame* frame);
+  virtual void didCreateFrame(WebKit::WebFrame* parent,
+                              WebKit::WebFrame* child);
   virtual void frameDetached(WebKit::WebFrame* frame);
   virtual void willClose(WebKit::WebFrame* frame);
   virtual void loadURLExternally(WebKit::WebFrame* frame,
                                  const WebKit::WebURLRequest& request,
                                  WebKit::WebNavigationPolicy policy);
   virtual void loadURLExternally(WebKit::WebFrame* frame,
                                  const WebKit::WebURLRequest& request,
                                  WebKit::WebNavigationPolicy policy,
                                  const WebKit::WebString& suggested_name);
   virtual WebKit::WebNavigationPolicy decidePolicyForNavigation(
@@ skipping 118 matching lines @@
       unsigned long long requested_size,
       WebKit::WebStorageQuotaCallbacks* callbacks);
   virtual void registerIntentService(
       WebKit::WebFrame* frame,
       const WebKit::WebIntentServiceInfo& service);
   virtual void dispatchIntent(WebKit::WebFrame* frame,
                               const WebKit::WebIntentRequest& intentRequest);
   virtual void willOpenSocketStream(
       WebKit::WebSocketStreamHandle* handle);
   virtual bool willCheckAndDispatchMessageEvent(
-      WebKit::WebFrame* source,
+      WebKit::WebFrame* sourceFrame,
+      WebKit::WebFrame* targetFrame,
       WebKit::WebSecurityOrigin targetOrigin,
       WebKit::WebDOMMessageEvent event) OVERRIDE;
   virtual WebKit::WebString userAgentOverride(
       WebKit::WebFrame* frame,
       const WebKit::WebURL& url) OVERRIDE;
 
   // WebKit::WebPageSerializerClient implementation ----------------------------
 
   virtual void didSerializeDataForFrame(
       const WebKit::WebURL& frame_url,
@@ skipping 342 matching lines @@
 #endif
 
   void OnZoom(content::PageZoom zoom);
   void OnZoomFactor(content::PageZoom zoom, int zoom_center_x,
                     int zoom_center_y);
 
   void OnEnableViewSourceMode();
 
   void OnJavaBridgeInit();
 
+  void OnUpdatedFrameTree(int process_id,
+                          int route_id,
+                          const std::string& frame_tree);
+
   // Adding a new message handler? Please add it in alphabetical order above
   // and put it in the same position in the .cc file.
 
   // Misc private functions ----------------------------------------------------
   void ZoomFactorHelper(content::PageZoom zoom, int zoom_center_x,
                         int zoom_center_y, float scaling_increment);
 
   void AltErrorPageFinished(WebKit::WebFrame* frame,
                             const WebKit::WebURLError& original_error,
                             const std::string& html);
 
   // Check whether the preferred size has changed.
   void CheckPreferredSize();
 
   WebKit::WebGraphicsContext3D* CreateGraphicsContext3D(
       const WebKit::WebGraphicsContext3D::Attributes& attributes);
 
+  // This method walks the entire frame tree for this RenderView and sends an
+  // update to the browser process as described in the
+  // ViewHostMsg_FrameTreeUpdated comments. If |exclude_frame_subtree|
+  // frame is non-NULL, the subtree starting at that frame not included in the
+  // serialized form.
+  // This is used when a frame is going to be removed from the tree.
+  void SendUpdatedFrameTree(WebKit::WebFrame* exclude_frame_subtree);
+
+  // Recursively creates a DOM frame tree starting with |frame|, based on
+  // |frame_tree|. For each node, the frame is navigated to the swapped out URL,
+  // the name (if present) is set on it, and all the subframes are created
+  // and added to the DOM.
+  void CreateFrameTree(WebKit::WebFrame* frame, DictionaryValue* frame_tree);
+
+  // If this is a swapped out RenderView, which maintains a copy of the frame
+  // tree of an active RenderView, we keep a map from frame ids in this view to
+  // the frame ids of the active view for each corresponding frame.
+  // This method uses the map to find the frame in this RenderView that
+  // corresponds to the frame in the active RenderView specified by |frame_id|.
+  WebKit::WebFrame* GetFrameByMappedID(int frame_id);
+
   void EnsureMediaStreamImpl();
 
   // This callback is triggered when DownloadFavicon completes, either
   // succesfully or with a failure. See DownloadFavicon for more
   // details.
   void DidDownloadFavicon(webkit_glue::ImageResourceFetcher* fetcher,
                           const SkBitmap& image);
 
   // Requests to download a favicon image. When done, the RenderView is notified
   // by way of DidDownloadFavicon. Returns true if the request was successfully
@@ skipping 28 matching lines @@
 #if defined(OS_ANDROID)
   // Launch an Android content intent with the given URL.
   void LaunchAndroidContentIntent(const GURL& intent_url, size_t request_id);
 #endif
 
   bool MaybeLoadAlternateErrorPage(WebKit::WebFrame* frame,
                                    const WebKit::WebURLError& error,
                                    bool replace);
 
   // Make this RenderView show an empty, unscriptable page.
-  void NavigateToSwappedOutURL();
+  void NavigateToSwappedOutURL(WebKit::WebFrame* frame);
 
   // If we initiated a navigation, this function will populate |document_state|
   // with the navigation information saved in OnNavigate().
   void PopulateDocumentStateFromPending(content::DocumentState* document_state);
 
   // Returns a new NavigationState populated with the navigation information
   // saved in OnNavigate().
   content::NavigationState* CreateNavigationStateFromPending();
 
   // Processes the command-line flags --enable-viewport and
@@ skipping 343 matching lines @@
   // guest RenderView.
   ppapi::HostResource guest_graphics_resource_;
 
   // This graphics context is initialized once GuestReady() is called.
   WebGraphicsContext3DCommandBufferImpl* guest_uninitialized_context_;
 
   // These are the attributes originally passed into createOutputSurface
   // before the guest_to_embedder_channel was ready.
   WebKit::WebGraphicsContext3D::Attributes guest_attributes_;
 
+  // Boolean indicating whether we are in the process of creating the frame
+  // tree for this renderer in response to ViewMsg_UpdateFrameTree.  If true,
+  // we won't be sending ViewHostMsg_FrameTreeUpdated messages back to the
+  // browser, as those will be redundant.
+  bool updating_frame_tree_;
+
+  // Boolean indicating that the frame tree has changed, but a message has not
+  // been sent to the browser because a page has been loading. This helps
+  // avoid extra messages being sent to the browser when navigating away from a
+  // page with subframes, which will be destroyed. Instead, a single message
+  // is sent when the load is stopped with the final state of the frame tree.
+  //
+  // TODO(nasko): Relying on the is_loading_ means that frame tree updates will
+  // not be sent until *all* subframes have completed loading. This can cause
+  // JavaScript calls to fail, if they occur prior to the first update message
+  // being sent. This will be fixed by bug http://crbug.com/145014.
+  bool pending_frame_tree_update_;
+
+  // If this render view is a swapped out "mirror" of an active render view in a
+  // different process, we record the process id and route id for the active RV.
+  // For further details, see the comments on ViewHostMsg_FrameTreeUpdated.
+  int target_process_id_;
+  int target_routing_id_;
+
+  // A map of the current process's frame ids to ids in the remote active render
+  // view, if this is a swapped out render view.
+  std::map<int, int> active_frame_id_map_;
+
   // NOTE: pepper_delegate_ should be last member because its constructor calls
   // AddObservers method of RenderViewImpl from c-tor.
   content::PepperPluginDelegateImpl pepper_delegate_;
 
   // ---------------------------------------------------------------------------
   // ADDING NEW DATA? Please see if it fits appropriately in one of the above
   // sections rather than throwing it randomly at the end. If you're adding a
   // bunch of stuff, you should probably create a helper class and put your
   // data and methods on that to avoid bloating RenderView more.  You can
   // use the Observer interface to filter IPC messages and receive frame change
   // notifications.
   // ---------------------------------------------------------------------------
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewImpl);
 };
 
 #endif  // CONTENT_RENDERER_RENDER_VIEW_IMPL_H_