Move LoadProgressTracker to the browser process.

content/browser/web_contents/web_contents_impl_browsertest.cc

 // 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.
 
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/public/browser/load_notification_details.h"
@@ skipping 140 matching lines @@
   gfx::Size rwhv_create_size_;
 };
 
 class LoadingStateChangedDelegate : public WebContentsDelegate {
  public:
   LoadingStateChangedDelegate()
       : loadingStateChangedCount_(0)
       , loadingStateToDifferentDocumentCount_(0) {
   }
 
-  // WebContentsDelgate:
+  // WebContentsDelegate:
   virtual void LoadingStateChanged(WebContents* contents,
                                    bool to_different_document) OVERRIDE {
       loadingStateChangedCount_++;
       if (to_different_document)
         loadingStateToDifferentDocumentCount_++;
   }
 
   int loadingStateChangedCount() const { return loadingStateChangedCount_; }
   int loadingStateToDifferentDocumentCount() const {
     return loadingStateToDifferentDocumentCount_;
@@ skipping 258 matching lines @@
 
   // LoadingStateChanged should be called 4 times: start and stop for the
   // initial load of push_state.html, and start and stop for the "navigation"
   // triggered by history.pushState(). However, the start notification for the
   // history.pushState() navigation should set to_different_document to false.
   EXPECT_EQ("pushState", shell()->web_contents()->GetURL().ref());
   EXPECT_EQ(4, delegate->loadingStateChangedCount());
   EXPECT_EQ(3, delegate->loadingStateToDifferentDocumentCount());
 }
 
+struct LoadProgressDelegateAndObserver : public WebContentsDelegate,
+                                         public WebContentsObserver {
+  LoadProgressDelegateAndObserver(Shell* shell)
+      : WebContentsObserver(shell->web_contents()),
+        did_start_loading(false),
+        did_stop_loading(false) {
+    web_contents()->SetDelegate(this);
+  }
+
+  // WebContentsDelegate:
+  virtual void LoadProgressChanged(WebContents* source,
+                                   double progress) OVERRIDE {
+    EXPECT_TRUE(did_start_loading);
+    EXPECT_FALSE(did_stop_loading);
+    progresses.push_back(progress);
+  }
+
+  // WebContentsObserver:
+  virtual void DidStartLoading(RenderViewHost* render_view_host) OVERRIDE {
+    EXPECT_FALSE(did_start_loading);
+    EXPECT_EQ(0U, progresses.size());
+    EXPECT_FALSE(did_stop_loading);
+    did_start_loading = true;
+  }
+
+  virtual void DidStopLoading(RenderViewHost* render_view_host) OVERRIDE {
+    EXPECT_TRUE(did_start_loading);
+    EXPECT_GE(progresses.size(), 1U);
+    EXPECT_FALSE(did_stop_loading);
+    did_stop_loading = true;
+  }
+
+  bool did_start_loading;
+  std::vector<double> progresses;
+  bool did_stop_loading;
+};
+
+IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest, LoadProgress) {
+  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
+  scoped_ptr<LoadProgressDelegateAndObserver> delegate(
+      new LoadProgressDelegateAndObserver(shell()));
+
+  NavigateToURL(shell(), embedded_test_server()->GetURL("/title1.html"));
+
+  const std::vector<double>& progresses = delegate->progresses;
+  // All updates should be in order ...
+  if (std::adjacent_find(progresses.begin(),
+                         progresses.end(),
+                         std::greater<double>()) != progresses.end()) {
+    ADD_FAILURE() << "Progress values should be in order: "
+                  << ::testing::PrintToString(progresses);
+  }
+
+  // ... and the last one should be 1.0, meaning complete.
+  ASSERT_GE(progresses.size(), 1U)
+      << "There should be at least one progress update";
+  EXPECT_EQ(1.0, *progresses.rbegin());
+}
+
 }  // namespace content