Adding previews information to PLM UKM

chrome/browser/page_load_metrics/observers/previews_ukm_observer_unittest.cc

Index: chrome/browser/page_load_metrics/observers/previews_ukm_observer_unittest.cc
diff --git a/chrome/browser/page_load_metrics/observers/previews_ukm_observer_unittest.cc b/chrome/browser/page_load_metrics/observers/previews_ukm_observer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..741a31bd396c0aa7e6c62f62754e8410bc4eae27
--- /dev/null
+++ b/chrome/browser/page_load_metrics/observers/previews_ukm_observer_unittest.cc
@@ -0,0 +1,280 @@
+// Copyright 2016 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/observers/previews_ukm_observer.h"
+
+#include "base/macros.h"
+#include "base/metrics/metrics_hashes.h"
+#include "base/optional.h"
+#include "chrome/browser/loader/chrome_navigation_data.h"
+#include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.h"
+#include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "components/data_reduction_proxy/core/browser/data_reduction_proxy_data.h"
+#include "components/ukm/test_ukm_recorder.h"
+#include "components/ukm/ukm_source.h"
+
+namespace previews {
+
+namespace {
+
+const char kDefaultTestUrl[] = "https://www.google.com";
+
+data_reduction_proxy::DataReductionProxyData* DataForNavigationHandle(
+    content::WebContents* web_contents,
+    content::NavigationHandle* navigation_handle) {
+  ChromeNavigationData* chrome_navigation_data = new ChromeNavigationData();
+  content::WebContentsTester::For(web_contents)
+      ->SetNavigationData(navigation_handle,
+                          base::WrapUnique(chrome_navigation_data));
+  data_reduction_proxy::DataReductionProxyData* data =
+      new data_reduction_proxy::DataReductionProxyData();
+  chrome_navigation_data->SetDataReductionProxyData(base::WrapUnique(data));
+
+  return data;
+}
+
+class TestPreviewsUKMObserver : public PreviewsUKMObserver {
+ public:
+  TestPreviewsUKMObserver(content::WebContents* web_contents,
+                          bool data_reduction_proxy_used,
+                          bool lite_page_received)
+      : web_contents_(web_contents),
+        data_reduction_proxy_used_(data_reduction_proxy_used),
+        lite_page_received_(lite_page_received) {}
+
+  ~TestPreviewsUKMObserver() override {}
+
+  // page_load_metrics::PageLoadMetricsObserver implementation:
+  ObservePolicy OnCommit(content::NavigationHandle* navigation_handle,
+                         ukm::SourceId source_id) override {
+    data_reduction_proxy::DataReductionProxyData* data =
+        DataForNavigationHandle(web_contents_, navigation_handle);
+    data->set_used_data_reduction_proxy(data_reduction_proxy_used_);
+    data->set_request_url(GURL(kDefaultTestUrl));
+    data->set_lite_page_received(lite_page_received_);
+    return PreviewsUKMObserver::OnCommit(navigation_handle, source_id);
+  }
+
+ private:
+  content::WebContents* web_contents_;
+  bool data_reduction_proxy_used_;
+  bool lite_page_received_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestPreviewsUKMObserver);
+};
+
+class PreviewsUKMObserverTest
+    : public page_load_metrics::PageLoadMetricsObserverTestHarness {
+ public:
+  PreviewsUKMObserverTest() {}
+  ~PreviewsUKMObserverTest() override {}
+
+  void SetUp() override {
+    page_load_metrics::PageLoadMetricsObserverTestHarness::SetUp();
+    TestingBrowserProcess::GetGlobal()->SetUkmRecorder(&test_ukm_recorder_);
+  }
+
+  void RunTest(bool data_reduction_proxy_used, bool lite_page_received) {
+    data_reduction_proxy_used_ = data_reduction_proxy_used;
+    lite_page_received_ = lite_page_received;
+    NavigateAndCommit(GURL(kDefaultTestUrl));
+  }
+
+  void ValidateUKM(int expected_value, ukm::SourceId source_id) {
+    ukm::mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source_id);
+    const ukm::mojom::UkmMetric* metric =
+        ukm::TestUkmRecorder::FindMetric(entry.get(), "previews_type");
+    if (expected_value == PREVIEWS_UKM_NONE) {
+      EXPECT_FALSE(metric);
+    } else {
+      EXPECT_EQ(entry->source_id, source_id);
+      EXPECT_EQ(entry->event_hash, base::HashMetricName("Previews"));
+      EXPECT_EQ(expected_value, metric->value);
+    }
+  }
+
+  size_t ukm_source_count() { return test_ukm_recorder_.sources_count(); }

[Bryan McQuade, 2017/07/03 16:56:52]

I have a change in flight: https://chromium-review.googlesource.com/c/558945/
which generalizes our PLM UKM test infra. I'll try to land this later this week.
LMK if any test functionality you need is missing. Thanks!

[RyanSturm, 2017/07/11 21:46:41]

Done.

+
+  size_t ukm_entry_count() { return test_ukm_recorder_.entries_count(); }
+
+  const ukm::UkmSource* GetUkmSourceForUrl(const char* url) {
+    return test_ukm_recorder_.GetSourceForUrl(url);
+  }
+
+  const ukm::mojom::UkmEntry* GetUkmEntry(size_t entry_index) {
+    return test_ukm_recorder_.GetEntry(entry_index);
+  }
+
+  std::vector<const ukm::mojom::UkmEntry*> GetUkmEntriesForSourceID(
+      ukm::SourceId source_id) {
+    std::vector<const ukm::mojom::UkmEntry*> entries;
+    for (size_t i = 0; i < ukm_entry_count(); ++i) {
+      const ukm::mojom::UkmEntry* entry = GetUkmEntry(i);
+      if (entry->source_id == source_id)
+        entries.push_back(entry);
+    }
+    return entries;
+  }
+
+  ukm::mojom::UkmEntryPtr GetMergedEntry(
+      const std::vector<const ukm::mojom::UkmEntry*>& entries) {
+    ukm::mojom::UkmEntryPtr merged_entry = ukm::mojom::UkmEntry::New();
+    for (const auto* entry : entries) {
+      if (merged_entry->event_hash) {
+        EXPECT_EQ(merged_entry->source_id, entry->source_id);
+        EXPECT_EQ(merged_entry->event_hash, entry->event_hash);
+      } else {
+        merged_entry->event_hash = entry->event_hash;
+        merged_entry->source_id = entry->source_id;
+      }
+      for (const auto& metric : entry->metrics) {
+        merged_entry->metrics.emplace_back(metric->Clone());
+      }
+    }
+    return merged_entry;
+  }
+
+  ukm::mojom::UkmEntryPtr GetMergedEntryForSourceID(ukm::SourceId source_id) {
+    ukm::mojom::UkmEntryPtr entry =
+        GetMergedEntry(GetUkmEntriesForSourceID(source_id));
+    return entry;
+  }
+
+ protected:
+  void RegisterObservers(page_load_metrics::PageLoadTracker* tracker) override {
+    tracker->AddObserver(base::MakeUnique<TestPreviewsUKMObserver>(
+        web_contents(), data_reduction_proxy_used_, lite_page_received_));
+    // Data is only added to the first navigation after RunTest().
+    data_reduction_proxy_used_ = false;
+    lite_page_received_ = false;
+  }
+
+ private:
+  bool data_reduction_proxy_used_ = false;
+  bool lite_page_received_ = false;
+
+  ukm::TestUkmRecorder test_ukm_recorder_;
+
+  DISALLOW_COPY_AND_ASSIGN(PreviewsUKMObserverTest);
+};
+
+TEST_F(PreviewsUKMObserverTest, NoPreviewSeen) {
+  RunTest(false /* data_reduction_proxy_used */,
+          false /* lite_page_received */);
+  ukm::SourceId source_id = observer()->GetUKMSourceForCommittedLoad().value();
+  NavigateToUntrackedUrl();
+
+  ValidateUKM(PREVIEWS_UKM_NONE, source_id);
+}
+
+TEST_F(PreviewsUKMObserverTest, LitePageSeen) {
+  RunTest(true /* data_reduction_proxy_used */, true /* lite_page_received */);
+
+  ukm::SourceId source_id = observer()->GetUKMSourceForCommittedLoad().value();
+
+  NavigateToUntrackedUrl();
+
+  ValidateUKM(PREVIEWS_UKM_LITE_PAGE, source_id);
+}
+
+TEST_F(PreviewsUKMObserverTest, ClientLoFiSeen) {
+  RunTest(false /* data_reduction_proxy_used */,
+          false /* lite_page_received */);
+  ukm::SourceId source_id = observer()->GetUKMSourceForCommittedLoad().value();
+  std::unique_ptr<data_reduction_proxy::DataReductionProxyData> data =
+      base::MakeUnique<data_reduction_proxy::DataReductionProxyData>();
+  data->set_client_lofi_requested(true);
+
+  // Prepare 3 resources of varying size and configurations, 2 of which have
+  // client LoFi set.
+  page_load_metrics::ExtraRequestCompleteInfo resources[] = {
+      {GURL(), net::HostPortPair(), -1, false /*was_cached*/,
+       1024 * 40 /* raw_body_bytes */,
+       1024 * 40 * 5 /* original_network_content_length */, std::move(data),
+       content::ResourceType::RESOURCE_TYPE_IMAGE, 0},
+      // Uncached non-proxied request.
+      {GURL(), net::HostPortPair(), -1, false /*was_cached*/,
+       1024 * 40 /* raw_body_bytes */,
+       1024 * 40 /* original_network_content_length */,
+       nullptr /* data_reduction_proxy_data */,
+       content::ResourceType::RESOURCE_TYPE_IMAGE, 0},
+  };
+
+  for (const auto& request : resources)
+    SimulateLoadedResource(request);
+
+  NavigateToUntrackedUrl();
+
+  ValidateUKM(PREVIEWS_UKM_CLIENT_LOFI, source_id);
+}
+
+TEST_F(PreviewsUKMObserverTest, ServerLoFiSeen) {
+  RunTest(true /* data_reduction_proxy_used */, false /* lite_page_received */);
+  ukm::SourceId source_id = observer()->GetUKMSourceForCommittedLoad().value();
+  std::unique_ptr<data_reduction_proxy::DataReductionProxyData> data =
+      base::MakeUnique<data_reduction_proxy::DataReductionProxyData>();
+  data->set_used_data_reduction_proxy(true);
+  data->set_lofi_received(true);
+
+  // Prepare 3 resources of varying size and configurations, 2 of which have
+  // client LoFi set.
+  page_load_metrics::ExtraRequestCompleteInfo resources[] = {
+      {GURL(), net::HostPortPair(), -1, false /*was_cached*/,
+       1024 * 40 /* raw_body_bytes */,
+       1024 * 40 * 5 /* original_network_content_length */, std::move(data),
+       content::ResourceType::RESOURCE_TYPE_IMAGE, 0},
+      {GURL(), net::HostPortPair(), -1, false /*was_cached*/,
+       1024 * 40 /* raw_body_bytes */,
+       1024 * 40 /* original_network_content_length */,
+       nullptr /* data_reduction_proxy_data */,
+       content::ResourceType::RESOURCE_TYPE_IMAGE, 0},
+  };
+
+  for (const auto& request : resources)
+    SimulateLoadedResource(request);
+
+  NavigateToUntrackedUrl();
+
+  ValidateUKM(PREVIEWS_UKM_SERVER_LOFI, source_id);
+}
+
+TEST_F(PreviewsUKMObserverTest, BothLoFiSeen) {
+  RunTest(true /* data_reduction_proxy_used */, false /* lite_page_received */);
+  ukm::SourceId source_id = observer()->GetUKMSourceForCommittedLoad().value();
+  std::unique_ptr<data_reduction_proxy::DataReductionProxyData> data1 =
+      base::MakeUnique<data_reduction_proxy::DataReductionProxyData>();
+  data1->set_used_data_reduction_proxy(true);
+  data1->set_lofi_received(true);
+
+  std::unique_ptr<data_reduction_proxy::DataReductionProxyData> data2 =
+      base::MakeUnique<data_reduction_proxy::DataReductionProxyData>();
+  data2->set_used_data_reduction_proxy(true);
+  data2->set_client_lofi_requested(true);
+
+  // Prepare 4 resources of varying size and configurations, 1 has Client LoFi,
+  // 1 has Server LoFi.
+  page_load_metrics::ExtraRequestCompleteInfo resources[] = {
+      // Uncached proxied request with .1 compression ratio.
+      {GURL(), net::HostPortPair(), -1, false /*was_cached*/,
+       1024 * 40 /* raw_body_bytes */,
+       1024 * 40 * 10 /* original_network_content_length */, std::move(data1),
+       content::ResourceType::RESOURCE_TYPE_IMAGE, 0},
+      // Uncached proxied request with .5 compression ratio.
+      {GURL(), net::HostPortPair(), -1, false /*was_cached*/,
+       1024 * 40 /* raw_body_bytes */,
+       1024 * 40 * 5 /* original_network_content_length */, std::move(data2),
+       content::ResourceType::RESOURCE_TYPE_IMAGE, 0},
+  };
+
+  for (const auto& request : resources)
+    SimulateLoadedResource(request);
+
+  NavigateToUntrackedUrl();
+  ValidateUKM(PREVIEWS_UKM_SERVER_LOFI | PREVIEWS_UKM_CLIENT_LOFI, source_id);
+}
+
+}  // namespace
+
+}  // namespace previews