Navigation transitions: Block first response until after transitions have run.

content/browser/transition_request_manager.h

Index: content/browser/transition_request_manager.h
diff --git a/content/browser/transition_request_manager.h b/content/browser/transition_request_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f7265dffc45cdf6d3712f93cb2a99a8b089fae7
--- /dev/null
+++ b/content/browser/transition_request_manager.h
@@ -0,0 +1,62 @@
+// 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 <utility>
+
+#include "base/basictypes.h"
+#include "base/synchronization/lock.h"
+
+template <typename T>
+struct DefaultSingletonTraits;
+
+namespace content {
+
+// TransitionRequestManager is used to handle bookkeeping for transition
+// requests and responses between the UI and IO threads.
+//
+// TransitionRequestManager is a singleton that may be used on any thread.
+//
+class TransitionRequestManager {
+ public:
+  // Returns the singleton instance.
+  static TransitionRequestManager* GetInstance();
+
+  // Returns whether the RenderFrameHost specified by the given IDs currently
+  // has a pending transition request. If so, we will have to delay the
+  // response until the embedder resumes the request.
+  bool HasPendingTransitionRequest(int process_id, int render_frame_id);
+
+  // Sets whether the RenderFrameHost specified by the given IDs currently has a
+  // pending transition request. Called by RenderFrameHost on the UI thread.
+  void SetHasPendingTransitionRequest(int process_id,
+                                      int render_frame_id,
+                                      bool has_pending);
+
+ private:
+  friend struct DefaultSingletonTraits<TransitionRequestManager>;
+  typedef std::set<std::pair<int, int> > RenderFrameSet;
+
+  TransitionRequestManager();
+  ~TransitionRequestManager();
+
+  // You must acquire this lock before reading or writing any members of this
+  // class.  You must not block while holding this lock.
+  base::Lock lock_;
+
+  // 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_;

[jam, 2014/06/11 02:00:21]

cross thread maps in general are bad for performance and maintainability. see
http://dev.chromium.org/developers/design-documents/threading#Overview. 

how often does CrossSiteResourceHandler need this? For every request? For every
main frame? Only for every cross-site request?

Either way, sine navigation is moving to the browser process as part of site
isolation and the navigation-in-browser project by the folks in the paris
office, i would presume that more of navigation will be on the UI thread?

[shatch, 2014/06/14 00:41:37]

Ok, I've reworked it and I think I have a much better solution! Instead of the
cross thread map, the plan is to have an IPC sent to the IO thread that gets
caught by the TransitionRequestMessageFilter and communicates with the
TransitionRequestManager to deliver the transition elements. When we reach
CSRH::OnResponseStarted and there are transition elements, a task is posted to
the UI thread to see if the embedder will handle the transition. If not, the
navigation is resumed. Under normal navigations, there's no additional cost
beyond the lookup in the TransitionRequestManager.

Had a meeting with Darin and Nasko a few weeks ago to go over the CSRH changes
here, and make sure there was nothing in these changes that wasn't compatible
with the new navigation plans. IIRC the CSRH may move/disappear but being able
to defer right at the start of the response didn't seem to be a problem.

[jam, 2014/06/16 03:46:10]

great that you got rid of the cross thread map, thanks.

one question, who sends TransitionRequestHostMsg_SetHasPendingTransitionRequest?

[shatch, 2014/06/16 22:32:19]

Right now the plan is to have it sent by blink when initiating a navigation.
This CL: https://codereview.chromium.org/319573008/ gets the serialized elements
from the document. Once that lands, the RFH can send the IPC.

+
+  DISALLOW_COPY_AND_ASSIGN(TransitionRequestManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_TRANSITION_REQUEST_MANAGER_H_