Navigation transitions: Plumb data from the outgoing renderer to the incoming renderer

content/browser/transition_request_manager.h

 // Copyright 2014 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_TRANSITION_REQUEST_MANAGER_H_
 #define CONTENT_BROWSER_TRANSITION_REQUEST_MANAGER_H_
 
-#include <set>
+#include <map>
+#include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "url/gurl.h"
 
 template <typename T>
 struct DefaultSingletonTraits;
 
 namespace net {
 class HttpResponseHeaders;
 }
+class GURL;
 
 namespace content {
 
+struct TransitionLayerData {

[nasko, 2014/08/04 13:36:48]

Adding a comment that this structure is passed between threads is useful, as it
will help people avoid mistakes when adding code to it.

[oystein (OOO til 10th of July), 2014/08/05 19:02:49]

Done.

+  TransitionLayerData();
+  ~TransitionLayerData();
+
+  std::string markup;
+  std::string css_selector;
+  scoped_refptr<net::HttpResponseHeaders> response_headers;
+  GURL request_url;
+};
+
 // TransitionRequestManager is used to handle bookkeeping for transition
 // requests and responses.
 //
 // TransitionRequestManager is a singleton and should only be accessed on the IO
 // thread.
 //
 class TransitionRequestManager {
  public:
   // Returns the singleton instance.
   CONTENT_EXPORT static TransitionRequestManager* GetInstance();
 
   // Parses out any transition-entering-stylesheet link headers from the
   // response headers.
   CONTENT_EXPORT static void ParseTransitionStylesheetsFromHeaders(
       const scoped_refptr<net::HttpResponseHeaders>& headers,
       std::vector<GURL>& entering_stylesheets,
       const GURL& resolve_address);
 
   // Returns whether the RenderFrameHost specified by the given IDs currently
-  // has a pending transition request. If so, we will have to delay the
+  // has any pending transition request data. If so, we will have to delay the
   // response until the embedder resumes the request.
-  bool HasPendingTransitionRequest(int process_id, int render_frame_id);
+  bool HasPendingTransitionRequest(int renderer_id,

[nasko, 2014/08/04 13:36:48]

nit: why drop the "process" part of the variable name? I think it makes it more
clear that we are dealing with a process identifier. The caller passes in
"render_process_id", which I find to be a really good name.

[oystein (OOO til 10th of July), 2014/08/05 19:02:49]

Done; unintentional change actually due to some merges, thanks for pointing it
out.

+                                   int render_frame_id,
+                                   const GURL& request_url,
+                                   TransitionLayerData* transition_data);
 
-  // Sets whether the RenderFrameHost specified by the given IDs currently has a
-  // pending transition request.
-  CONTENT_EXPORT void SetHasPendingTransitionRequest(int process_id,
-                                                     int render_frame_id,
-                                                     bool has_pending);
+  // Adds pending request data for a transition navigation for the
+  // RenderFrameHost specified by the given IDs.
+  CONTENT_EXPORT void AddPendingTransitionRequestData(
+      int renderer_id,
+      int render_view_id,

[nasko, 2014/08/04 13:36:48]

Isn't this render_frame_id?

[oystein (OOO til 10th of July), 2014/08/05 19:02:49]

Done; same as above.

+      const std::string& origin,
+      const std::string& css_selector,
+      const std::string& markup);
+
+  void ClearPendingTransitionRequestData(int renderer_id, int render_frame_id);
 
  private:
+  class TransitionRequestData {
+   public:
+      TransitionRequestData();
+      ~TransitionRequestData();
+      void AddEntry(const std::string& origin,
+                    const std::string& selector,
+                    const std::string& markup);
+      bool FindEntry(const GURL& request_url,
+                     TransitionLayerData* transition_data);
+
+   private:
+      struct AllowedEntry {
+          std::string origin;
+          std::string css_selector;
+          std::string markup;
+
+          AllowedEntry(const std::string& origin,
+                       const std::string& css_selector,
+                       const std::string& markup) :
+              origin(origin),
+              css_selector(css_selector),
+              markup(markup) {}
+      };
+      std::vector<AllowedEntry> allowed_entries_;
+  };
+
   friend struct DefaultSingletonTraits<TransitionRequestManager>;
-  typedef std::set<std::pair<int, int> > RenderFrameSet;
+  typedef std::map<std::pair<int, int>, TransitionRequestData>
+      RenderFrameRequestDataMap;
 
   TransitionRequestManager();
   ~TransitionRequestManager();
 
-  // Set of (render_process_host_id, render_frame_id) pairs of all
-  // RenderFrameHosts that have pending transition requests. Used to pass
-  // information to the CrossSiteResourceHandler without doing a round-trip
-  // between IO->UI->IO threads.
-  RenderFrameSet pending_transition_frames_;
+  // Map of (render_process_host_id, render_frame_id) pairs of all
+  // RenderFrameHosts that have pending cross-site requests and their data.
+  // Used to pass information to the CrossSiteResourceHandler without doing a
+  // round-trip between IO->UI->IO threads.
+  RenderFrameRequestDataMap pending_transition_frames_;
 
   DISALLOW_COPY_AND_ASSIGN(TransitionRequestManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_TRANSITION_REQUEST_MANAGER_H_