Move load progress tracking logic to the frame tree.

content/browser/frame_host/frame_tree_node.h

 // Copyright 2013 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_FRAME_HOST_FRAME_TREE_NODE_H_
 #define CONTENT_BROWSER_FRAME_HOST_FRAME_TREE_NODE_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 12 matching lines @@
 class FrameTree;
 class Navigator;
 class RenderFrameHostImpl;
 
 // When a page contains iframes, its renderer process maintains a tree structure
 // of those frames. We are mirroring this tree in the browser process. This
 // class represents a node in this tree and is a wrapper for all objects that
 // are frame-specific (as opposed to page-specific).
 class CONTENT_EXPORT FrameTreeNode {
  public:
+  // These values indicate the loading progress status. The minimum progress
+  // value matches what Blink's ProgressTracker has traditionally used for a
+  // minimum progress value.

[nasko, 2015/03/24 17:26:11]

nit: I still think we can hide those to be private/anonymous values in follow-up
CLs, so a TODO for that might be useful to have.

[Fabrice (no longer in Chrome), 2015/03/25 17:35:01]

The issue is that right now, we need to access these values from FrameTree and I
do not think that is going to change.

[nasko, 2015/03/25 22:48:03]

It can be hidden from FrameTree, as it will not need to tell FTN anything. Once
we move the IPC to be handled by RFH, it will be telling FTN about its status.
This will be more clear once we do that work though.

[Fabrice (no longer in Chrome), 2015/03/26 11:05:24]

I'm readding the TODO, we'll see if we can remove it after moving the IPCs.

+  static const double kLoadingProgressNotStarted;
+  static const double kLoadingProgressMinimum;
+  static const double kLoadingProgressDone;
+
   // Returns the FrameTreeNode with the given global |frame_tree_node_id|,
   // regardless of which FrameTree it is in.
   static FrameTreeNode* GloballyFindByID(int64 frame_tree_node_id);
 
   FrameTreeNode(FrameTree* frame_tree,
                 Navigator* navigator,
                 RenderFrameHostDelegate* render_frame_delegate,
                 RenderViewHostDelegate* render_view_delegate,
                 RenderWidgetHostDelegate* render_widget_delegate,
                 RenderFrameHostManager::Delegate* manager_delegate,
@@ skipping 72 matching lines @@
   const FrameReplicationState& current_replication_state() const {
     return replication_state_;
   }
 
   RenderFrameHostImpl* current_frame_host() const {
     return render_manager_.current_frame_host();
   }
 
   bool IsDescendantOf(FrameTreeNode* other) const;
 
-  // Returns true if this frame is in a loading state.
+  // Returns true if this node is in a loading state.
   bool IsLoading() const;
 
-  // Returns the loading progress of this frame.
-  double GetLoadingProgress() const;
+  // Sets this node's loading progress (from 0 to 1).
+  void set_loading_progress(double loading_progress) {
+    loading_progress_ = loading_progress;
+  }
+
+  // Returns this node's loading progress.
+  double loading_progress() const { return loading_progress_; }
 
  private:
   void set_parent(FrameTreeNode* parent) { parent_ = parent; }
 
   // The next available browser-global FrameTreeNode ID.
   static int64 next_frame_tree_node_id_;
 
   // The FrameTree that owns us.
   FrameTree* frame_tree_;  // not owned.
 
@@ skipping 31 matching lines @@
   // Track the effective sandbox flags for this frame.  When a parent frame
   // dynamically updates sandbox flags for a child frame, the child's updated
   // sandbox flags are stored in replication_state_.sandbox_flags. However, the
   // update only takes effect on the next frame navigation, so the effective
   // sandbox flags are tracked separately here.  When enforcing sandbox flags
   // directives in the browser process, |effective_sandbox_flags_| should be
   // used.  |effective_sandbox_flags_| is updated with any pending sandbox
   // flags when a navigation for this frame commits.
   SandboxFlags effective_sandbox_flags_;
 
+  // Used to track this node's loading progress (from 0 to 1).
+  double loading_progress_;
+
   DISALLOW_COPY_AND_ASSIGN(FrameTreeNode);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FRAME_HOST_FRAME_TREE_NODE_H_