Update OnCommit to return ObservePolicy.

chrome/browser/page_load_metrics/metrics_web_contents_observer_unittest.cc

 // Copyright (c) 2015 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 "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 12 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace page_load_metrics {
 
 namespace {
 
 const char kDefaultTestUrl[] = "https://google.com/";
 const char kDefaultTestUrlAnchor[] = "https://google.com/#samepage";
 const char kDefaultTestUrl2[] = "https://whatever.com/";
+const char kFilteredCommitUrl[] = "https://whatever.com/ignore-on-commit";
 
 // Simple PageLoadMetricsObserver that copies observed PageLoadTimings into the
 // provided std::vector, so they can be analyzed by unit tests.
 class TestPageLoadMetricsObserver : public PageLoadMetricsObserver {
  public:
-  explicit TestPageLoadMetricsObserver(
-      std::vector<PageLoadTiming>* updated_timings,
-      std::vector<PageLoadTiming>* complete_timings,
-      std::vector<GURL>* observed_committed_urls)
+  TestPageLoadMetricsObserver(std::vector<PageLoadTiming>* updated_timings,
+                              std::vector<PageLoadTiming>* complete_timings,
+                              std::vector<GURL>* observed_committed_urls)
       : updated_timings_(updated_timings),
         complete_timings_(complete_timings),
         observed_committed_urls_(observed_committed_urls) {}
 
   void OnStart(content::NavigationHandle* navigation_handle,
                const GURL& currently_committed_url,
                bool started_in_foreground) override {
     observed_committed_urls_->push_back(currently_committed_url);
   }
 
@@ skipping 12 matching lines @@
       const PageLoadExtraInfo& extra_info) override {
     return STOP_OBSERVING;
   }
 
  private:
   std::vector<PageLoadTiming>* const updated_timings_;
   std::vector<PageLoadTiming>* const complete_timings_;
   std::vector<GURL>* const observed_committed_urls_;
 };
 
+// Test PageLoadMetricsObserver that stops observing page loads with certain
+// substrings in the URL.
+class FilteringPageLoadMetricsObserver : public PageLoadMetricsObserver {
+ public:
+  explicit FilteringPageLoadMetricsObserver(
+      std::vector<GURL>* completed_filtered_urls)
+      : completed_filtered_urls_(completed_filtered_urls) {}
+
+  ObservePolicy OnCommit(content::NavigationHandle* handle) override {
+    const bool should_ignore =
+        handle->GetURL().spec().find("ignore-on-commit") != std::string::npos;
+    return should_ignore ? STOP_OBSERVING : CONTINUE_OBSERVING;
+  }
+
+  void OnComplete(const PageLoadTiming& timing,
+                  const PageLoadExtraInfo& extra_info) override {
+    completed_filtered_urls_->push_back(extra_info.committed_url);
+  }
+
+ private:
+  std::vector<GURL>* const completed_filtered_urls_;
+};
+
 class TestPageLoadMetricsEmbedderInterface
     : public PageLoadMetricsEmbedderInterface {
  public:
   TestPageLoadMetricsEmbedderInterface()
       : is_prerendering_(false), is_ntp_(false) {}
 
   bool IsPrerendering(content::WebContents* web_contents) override {
     return is_prerendering_;
   }
   bool IsNewTabPageUrl(const GURL& url) override { return is_ntp_; }
   void set_is_prerendering(bool is_prerendering) {
     is_prerendering_ = is_prerendering;
   }
   void set_is_ntp(bool is_ntp) { is_ntp_ = is_ntp; }
   void RegisterObservers(PageLoadTracker* tracker) override {
     tracker->AddObserver(base::MakeUnique<TestPageLoadMetricsObserver>(
         &updated_timings_, &complete_timings_, &observed_committed_urls_));
+    tracker->AddObserver(base::MakeUnique<FilteringPageLoadMetricsObserver>(
+        &completed_filtered_urls_));
   }
   const std::vector<PageLoadTiming>& updated_timings() const {
     return updated_timings_;
   }
   const std::vector<PageLoadTiming>& complete_timings() const {
     return complete_timings_;
   }
 
   // currently_committed_urls passed to OnStart().
   const std::vector<GURL>& observed_committed_urls_from_on_start() const {
     return observed_committed_urls_;
   }
 
+  // committed URLs passed to FilteringPageLoadMetricsObserver::OnComplete().
+  const std::vector<GURL>& completed_filtered_urls() const {
+    return completed_filtered_urls_;
+  }
+
  private:
   std::vector<PageLoadTiming> updated_timings_;
   std::vector<PageLoadTiming> complete_timings_;
   std::vector<GURL> observed_committed_urls_;
+  std::vector<GURL> completed_filtered_urls_;
   bool is_prerendering_;
   bool is_ntp_;
 };
 
 }  //  namespace
 
 class MetricsWebContentsObserverTest : public ChromeRenderViewHostTestHarness {
  public:
   MetricsWebContentsObserverTest() : num_errors_(0) {}
 
@@ skipping 51 matching lines @@
     return embedder_interface_->complete_timings().size();
   }
   int CountUpdatedTimingReported() {
     return embedder_interface_->updated_timings().size();
   }
 
   const std::vector<GURL>& observed_committed_urls_from_on_start() const {
     return embedder_interface_->observed_committed_urls_from_on_start();
   }
 
+  const std::vector<GURL>& completed_filtered_urls() const {
+    return embedder_interface_->completed_filtered_urls();
+  }
+
  protected:
   base::HistogramTester histogram_tester_;
   TestPageLoadMetricsEmbedderInterface* embedder_interface_;
   MetricsWebContentsObserver* observer_;
 
  private:
   int num_errors_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsWebContentsObserverTest);
 };
@@ skipping 327 matching lines @@
   DeleteContents();
 
   histogram_tester_.ExpectTotalCount(
       internal::kPageLoadCompletedAfterAppBackground, 2);
   histogram_tester_.ExpectBucketCount(
       internal::kPageLoadCompletedAfterAppBackground, false, 1);
   histogram_tester_.ExpectBucketCount(
       internal::kPageLoadCompletedAfterAppBackground, true, 1);
 }
 
+TEST_F(MetricsWebContentsObserverTest, StopObservingOnCommit) {
+  content::WebContentsTester* web_contents_tester =
+      content::WebContentsTester::For(web_contents());
+  ASSERT_TRUE(completed_filtered_urls().empty());
+
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
+  ASSERT_TRUE(completed_filtered_urls().empty());
+
+  // kFilteredCommitUrl should stop observing in OnCommit, and thus should not
+  // reach OnComplete().
+  web_contents_tester->NavigateAndCommit(GURL(kFilteredCommitUrl));
+  ASSERT_EQ(std::vector<GURL>({GURL(kDefaultTestUrl)}),
+            completed_filtered_urls());
+
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl2));
+  ASSERT_EQ(std::vector<GURL>({GURL(kDefaultTestUrl)}),
+            completed_filtered_urls());
+
+  web_contents_tester->NavigateAndCommit(GURL(kDefaultTestUrl));
+  ASSERT_EQ(std::vector<GURL>({GURL(kDefaultTestUrl), GURL(kDefaultTestUrl2)}),
+            completed_filtered_urls());
+}
+
 }  // namespace page_load_metrics