[Page Load Metrics] PageLoadMetrics Mojofication.

chrome/browser/page_load_metrics/page_load_metrics_browsertest.cc

 // Copyright 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 "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "chrome/browser/page_load_metrics/metrics_web_contents_observer.h"
 #include "chrome/browser/page_load_metrics/observers/aborts_page_load_metrics_observer.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_observer.h"
+#include "content/public/test/web_contents_binding_set_test_binder.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
 #include "net/http/failing_http_transaction_factory.h"
 #include "net/http/http_cache.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "testing/gmock/include/gmock/gmock.h"
 
 namespace {
 
 // Waits until a PageLoadMetricsMsg_TimingUpdated message IPC is received
 // matching a PageLoadTiming. See WaitForMatchingIPC for details.
 class TimingUpdatedObserver : public content::BrowserMessageFilter {
  public:
   // A bitvector to express which timing fields to match on.
   enum ExpectedTimingFields {
     FIRST_PAINT = 1 << 0,
@@ skipping 102 matching lines @@
   ~TimingUpdatedObserver() override {}
 
   std::unique_ptr<base::RunLoop> run_loop_;
   int matching_fields_ = 0;  // A bitvector composed from ExpectedTimingFields.
   bool matched_timing_update_ = false;
   int match_document_write_block_reload_ = 0;
 };
 
 }  // namespace
 
+namespace page_load_metrics {
+
+class MockPageLoadMetrics : public mojom::PageLoadMetrics {
+ public:
+  MockPageLoadMetrics() {}
+  ~MockPageLoadMetrics() override {}
+  MOCK_METHOD2(UpdateTiming,
+               void(const PageLoadTiming&, const PageLoadMetadata&));
+};
+
+}  // namespace page_load_metrics
+
+namespace {
+
+class FakePageLoadMetricsBinder
+    : public content::WebContentsBindingSetTestBinder<
+          page_load_metrics::mojom::PageLoadMetrics> {
+ public:
+  FakePageLoadMetricsBinder(
+      page_load_metrics::mojom::PageLoadMetrics* page_load_metrics)
+      : page_load_metrics_(page_load_metrics) {}
+  ~FakePageLoadMetricsBinder() override {}
+
+  void BindRequest(content::RenderFrameHost* frame_host,
+                   page_load_metrics::mojom::PageLoadMetricsAssociatedRequest
+                       request) override {
+    bindings_.AddBinding(page_load_metrics_, std::move(request), frame_host);
+  }
+
+ private:
+  page_load_metrics::mojom::PageLoadMetrics* page_load_metrics_;
+  mojo::AssociatedBindingSet<page_load_metrics::mojom::PageLoadMetrics,
+                             content::RenderFrameHost*>
+      bindings_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakePageLoadMetricsBinder);
+};
+
+}  // namespace
+
 class PageLoadMetricsBrowserTest : public InProcessBrowserTest {
  public:
   PageLoadMetricsBrowserTest() {}
   ~PageLoadMetricsBrowserTest() override {}
 
  protected:
   void NavigateToUntrackedUrl() {
     ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
   }
 
   bool NoPageLoadMetricsRecorded() {
     // Determine whether any 'public' page load metrics are recorded. We exclude
     // 'internal' metrics as these may be recorded for debugging purposes.
     size_t total_pageload_histograms =
         histogram_tester_.GetTotalCountsForPrefix("PageLoad.").size();
     size_t total_internal_histograms =
         histogram_tester_.GetTotalCountsForPrefix("PageLoad.Internal.").size();
     DCHECK_GE(total_pageload_histograms, total_internal_histograms);
     return total_pageload_histograms - total_internal_histograms == 0;
   }
 
   scoped_refptr<TimingUpdatedObserver> CreateTimingUpdatedObserver() {
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
+    if (!mock_page_load_metrics_) {

[Bryan McQuade, 2017/04/26 16:04:34]

just so i better understand, why is this needed in this browsertest if we've
written a separate browsertest for exercising the mojo codepath?

fwiw i am still hopeful we can merge the 2 browsertests into one, but in the
absence of a merge it seems odd that we have to do so much mojo setup for a
browsertest that isn't actually doing anything with mojo

[lpy, 2017/04/27 10:58:35]

Done, I forgot to remove this part.

As I mentioned before, the reason I didn't add it to exist browser test set, is
because we need to set the feature state before the render process is created,
in order for it to inherit the feature state from the browser process. That is
to say, we can't config Finch Trial for individual test case, we can only turn
it on for a browser test set.

+      mock_page_load_metrics_.reset(
+          new page_load_metrics::MockPageLoadMetrics());
+      content::WebContentsBindingSet::GetForWebContents<
+          page_load_metrics::mojom::PageLoadMetrics>(web_contents)
+          ->SetBinderForTesting(base::MakeUnique<FakePageLoadMetricsBinder>(
+              mock_page_load_metrics_.get()));
+    }
     scoped_refptr<TimingUpdatedObserver> observer(new TimingUpdatedObserver(
         web_contents->GetRenderViewHost()->GetWidget()));
     return observer;
   }
 
+  std::unique_ptr<page_load_metrics::MockPageLoadMetrics>
+      mock_page_load_metrics_;
   base::HistogramTester histogram_tester_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PageLoadMetricsBrowserTest);
 };
 
 void FailAllNetworkTransactions(net::URLRequestContextGetter* getter) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   net::HttpCache* cache(
       getter->GetURLRequestContext()->http_transaction_factory()->GetCache());
@@ skipping 584 matching lines @@
   ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(
                                               "/page_load_metrics/large.html"));
   NavigateToUntrackedUrl();
 
   histogram_tester_.ExpectTotalCount(internal::kHistogramTotalBytes, 1);
 
   // Verify that there is a single sample recorded in the 10kB bucket (the size
   // of the main HTML response).
   histogram_tester_.ExpectBucketCount(internal::kHistogramTotalBytes, 10, 1);
 }