Move LoadProgressTracker to the browser process.

content/browser/web_contents/web_contents_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_WEB_CONTENTS_WEB_CONTENTS_IMPL_H_
 #define CONTENT_BROWSER_WEB_CONTENTS_WEB_CONTENTS_IMPL_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 322 matching lines @@
   virtual bool Send(IPC::Message* message) OVERRIDE;
 
   // RenderFrameHostDelegate ---------------------------------------------------
   virtual bool OnMessageReceived(RenderFrameHost* render_frame_host,
                                  const IPC::Message& message) OVERRIDE;
   virtual const GURL& GetMainFrameLastCommittedURL() const OVERRIDE;
   virtual void RenderFrameCreated(RenderFrameHost* render_frame_host) OVERRIDE;
   virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) OVERRIDE;
   virtual void DidStartLoading(RenderFrameHost* render_frame_host,
                                bool to_different_document) OVERRIDE;
-  virtual void DidStopLoading(RenderFrameHost* render_frame_host) OVERRIDE;
   virtual void SwappedOut(RenderFrameHost* render_frame_host) OVERRIDE;
   virtual void WorkerCrashed(RenderFrameHost* render_frame_host) OVERRIDE;
   virtual void ShowContextMenu(RenderFrameHost* render_frame_host,
                                const ContextMenuParams& params) OVERRIDE;
   virtual void RunJavaScriptMessage(RenderFrameHost* render_frame_host,
                                     const base::string16& message,
                                     const base::string16& default_prompt,
                                     const GURL& frame_url,
                                     JavaScriptMessageType type,
                                     IPC::Message* reply_msg) OVERRIDE;
@@ skipping 28 matching lines @@
   virtual void UpdateTitle(RenderViewHost* render_view_host,
                            int32 page_id,
                            const base::string16& title,
                            base::i18n::TextDirection title_direction) OVERRIDE;
   virtual void UpdateEncoding(RenderViewHost* render_view_host,
                               const std::string& encoding) OVERRIDE;
   virtual void UpdateTargetURL(int32 page_id, const GURL& url) OVERRIDE;
   virtual void Close(RenderViewHost* render_view_host) OVERRIDE;
   virtual void RequestMove(const gfx::Rect& new_bounds) OVERRIDE;
   virtual void DidCancelLoading() OVERRIDE;
-  virtual void DidChangeLoadProgress(double progress) OVERRIDE;
   virtual void DocumentAvailableInMainFrame(
       RenderViewHost* render_view_host) OVERRIDE;
   virtual void RouteCloseEvent(RenderViewHost* rvh) OVERRIDE;
   virtual void RouteMessageEvent(
       RenderViewHost* rvh,
       const ViewMsg_PostMessage_Params& params) OVERRIDE;
   virtual bool AddMessageToConsole(int32 level,
                                    const base::string16& message,
                                    int32 line_no,
                                    const base::string16& source_id) OVERRIDE;
@@ skipping 304 matching lines @@
   void OnDidLoadResourceFromMemoryCache(const GURL& url,
                                         const std::string& security_info,
                                         const std::string& http_request,
                                         const std::string& mime_type,
                                         ResourceType::Type resource_type);
   void OnDidDisplayInsecureContent();
   void OnDidRunInsecureContent(const std::string& security_origin,
                                const GURL& target_url);
   void OnDocumentLoadedInFrame();
   void OnDidFinishLoad(const GURL& url);
+  void OnDidStartLoading(bool to_different_document);
+  void OnDidStopLoading();
+  void OnDidChangeLoadProgress(double load_progress);
   void OnGoToEntryAtOffset(int offset);
   void OnUpdateZoomLimits(int minimum_percent,
                           int maximum_percent,
                           bool remember);
   void OnEnumerateDirectory(int request_id, const base::FilePath& path);
 
   void OnRegisterProtocolHandler(const std::string& protocol,
                                  const GURL& url,
                                  const base::string16& title,
                                  bool user_gesture);
@@ skipping 100 matching lines @@
 
   // Finds the new RenderWidgetHost and returns it. Note that this can only be
   // called once as this call also removes it from the internal map.
   RenderWidgetHostView* GetCreatedWidget(int route_id);
 
   // Finds the new WebContentsImpl by route_id, initializes it for
   // renderer-initiated creation, and returns it. Note that this can only be
   // called once as this call also removes it from the internal map.
   WebContentsImpl* GetCreatedWindow(int route_id);
 
+  // Tracking loading progress -------------------------------------------------
+
+  // Resets the tracking state of the current load.
+  void ResetLoadProgressState();
+
+  // Calculates the progress of the current load and notifies the delegate.
+  void SendLoadProgressChanged();
+
+  // Called once when the last frame on the page has stopped loading.
+  void DidStopLoading(RenderFrameHost* render_frame_host);
+
   // Misc non-view stuff -------------------------------------------------------
 
   // Helper functions for sending notifications.
   void NotifySwapped(RenderViewHost* old_host, RenderViewHost* new_host);
   void NotifyDisconnected();
 
   void SetEncoding(const std::string& encoding);
 
   // TODO(creis): This should take in a FrameTreeNode to know which node's
   // render manager to return.  For now, we just return the root's.
@@ skipping 110 matching lines @@
   bool waiting_for_response_;
 
   // Map of SiteInstance ID to max page ID for this tab. A page ID is specific
   // to a given tab and SiteInstance, and must be valid for the lifetime of the
   // WebContentsImpl.
   std::map<int32, int32> max_page_ids_;
 
   // The current load state and the URL associated with it.
   net::LoadStateWithParam load_state_;
   base::string16 load_state_host_;
+
+  // LoadingProgressMap maps FrameTreeNode IDs to a double representing that
+  // frame's completion (from 0 to 1).
+  typedef base::hash_map<int64, double> LoadingProgressMap;

[nasko, 2014/05/05 23:51:12]

I think this is the right choice, but one note here. When doing a cross-process
navigation, we start in one process, then in another, and if the navigation will
commit we stop the first process and let the new one finish the navigation.
I know we see didStartProvisionalLoad from both processes, not sure about
didStartLoading. If that's the case, we will overwrite the map entry.

[Avi (use Gerrit), 2014/05/06 00:03:40]

I am not experienced enough in the loading code to know the details of how
things flow here. If you have advice I'd be happy to take it.

[Nate Chapin, 2014/05/07 20:16:02]

Unless we create a way to notify the new process that it is a continuation of a
load that was initiated in a different process, then yes, we will receive
didStartLoading() from both processes. I would think that it's straightforward
to account for that case in WebContentsImpl?

[Charlie Reis, 2014/05/07 23:51:00]

Yes, I don't think it should cause a big problem.  Maybe progress will go
backwards during the swap (depending on whether we start reporting progress
before commit), but we'll have the same FrameTreeNode ID after the swap.

Would make sense to cover this case in a browser test, though, to make sure it
doesn't hit any unexpected checks.

[Nate Chapin, 2014/05/08 00:19:45]

We should be able to avoid going backwards in the continuation case. Currently,
we set a minimum completion of 0.1 at load start, and I don't think we increase
it only when data is received (which should mean no sooner than commit time,
when we're in the correct process).

[Avi (use Gerrit), 2014/05/13 21:08:08]

**THIS ISSUE REMAINS UNADDRESSED**

In the continuation case, does the old frame indicate that its loading has
ended? If so, this shouldn't be horrible. OTOH, if it doesn't, then things will
wait forever.

You refer to a browser test. I need one for this case. Is there a good way to
construct one? We need a good way to churn those out, so that we can test that
case in key places.

[Charlie Reis, 2014/05/13 22:44:37]

We may need to try this out to be sure, since I'm not sure if we'll always hear
a stop from the old frame.  I think transfers should start in one process, issue
a DidFail + DidStop, and then be taken over by the new process. 
Browser-initiated cross-process navigations take a different path, and Nasko
thinks that may have an extra DidStart, but he's checking.  This is all just
speculation on my part, though.
Yes, I think WebContentsImplBrowserTest has a set of LoadingStateChanged tests. 
Nick may be able to help you with setting one up for cross-process subframes if
we want to exercise that path.

[Avi (use Gerrit), 2014/05/14 00:14:32]

This already does a good job of failing just about every CrossSiteTransferTest
and half the SitePerProcessBrowserTests. Can I rely on those?

[Charlie Reis, 2014/05/14 17:18:33]

Yeah, the SitePerProcessBrowserTests exercise the subframe loading case and
should be sufficient.  Note that there's a TODO in NavigateIframeToURL hacking
around this issue: we're listening for a commit instead of load stop, because of
the duplicate load start/stops.

(I think Nasko's new NavigateFrameToURL utility method also does this.)

I mention this because it's fine if we end up hiding these duplicate start/stops
and make it possible for tests to listen for load stop again.  Not sure if
that'll happen here, though.

+  LoadingProgressMap loading_progresses_;
+  double loading_total_progress_;
+
+  base::TimeTicks loading_last_progress_update_;
+
+  base::WeakPtrFactory<WebContentsImpl> loading_weak_factory_;
+
+  // Counter to track how many frames have sent start notifications but not
+  // stop notifications.
+  int loading_frames_in_progress_;
+
   // Upload progress, for displaying in the status bar.
   // Set to zero when there is no significant upload happening.
   uint64 upload_size_;
   uint64 upload_position_;
 
   // Data for current page -----------------------------------------------------
 
   // When a title cannot be taken from any entry, this title will be used.
   base::string16 page_title_when_no_navigation_entry_;
 
@@ skipping 136 matching lines @@
 
   // Whether the last JavaScript dialog shown was suppressed. Used for testing.
   bool last_dialog_suppressed_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_WEB_CONTENTS_WEB_CONTENTS_IMPL_H_