[Domain Reliability: Monitor] Report beacon if the go away is detected, regardless of request statu…

components/domain_reliability/context_unittest.cc

 // Copyright 2014 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 "components/domain_reliability/context.h"
 
 #include <stddef.h>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 15 matching lines @@
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 
 typedef std::vector<const DomainReliabilityBeacon*> BeaconVector;
 
 scoped_ptr<DomainReliabilityBeacon> MakeCustomizedBeacon(
     MockableTime* time,
     std::string status,
-    std::string quic_error) {
+    std::string quic_error,
+    bool quic_port_migration_detected) {
   scoped_ptr<DomainReliabilityBeacon> beacon(new DomainReliabilityBeacon());
   beacon->url = GURL("https://localhost/");
   beacon->status = status;
   beacon->quic_error = quic_error;
   beacon->chrome_error = net::ERR_CONNECTION_RESET;
   beacon->server_ip = "127.0.0.1";
   beacon->was_proxied = false;
   beacon->protocol = "HTTP";
   beacon->details.quic_broken = true;
+  beacon->details.quic_port_migration_detected = quic_port_migration_detected;
   beacon->http_response_code = -1;
   beacon->elapsed = base::TimeDelta::FromMilliseconds(250);
   beacon->start_time = time->NowTicks() - beacon->elapsed;
   beacon->upload_depth = 0;
   beacon->sample_rate = 1.0;
   return beacon;
 }
 
 scoped_ptr<DomainReliabilityBeacon> MakeBeacon(MockableTime* time) {
-  return MakeCustomizedBeacon(time, "tcp.connection_reset", "");
+  return MakeCustomizedBeacon(time, "tcp.connection_reset", "", false);
 }
 
 template <typename ValueType,
           bool (DictionaryValue::* GetValueType)(const std::string&,
                                                  ValueType*) const>
 struct HasValue {
   bool operator()(const DictionaryValue& dict,
                   const std::string& key,
                   ValueType expected_value) {
     ValueType actual_value;
@@ skipping 182 matching lines @@
   // Check that both beacons were uploaded.
   DomainReliabilityUploader::UploadResult result;
   result.status = DomainReliabilityUploader::UploadResult::SUCCESS;
   CallUploadCallback(result);
 
   EXPECT_TRUE(CheckNoBeacons());
 }
 
 TEST_F(DomainReliabilityContextTest, ReportUpload) {
   InitContext(MakeTestConfig());
-  context_->OnBeacon(MakeBeacon(&time_));
+  context_->OnBeacon(
+      MakeCustomizedBeacon(&time_, "tcp.connection_reset", "", true));
 
   BeaconVector beacons;
   context_->GetQueuedBeaconsForTesting(&beacons);
   EXPECT_EQ(1u, beacons.size());
 
   time_.Advance(max_delay());
   EXPECT_TRUE(upload_pending());
   EXPECT_EQ(0, upload_max_depth());
   EXPECT_EQ(GURL("https://exampleuploader/upload"), upload_url());
 
   scoped_ptr<Value> value = base::JSONReader::Read(upload_report());
   const DictionaryValue* entry;
   ASSERT_TRUE(GetEntryFromReport(value.get(), 0, &entry));
   EXPECT_TRUE(HasStringValue(*entry, "failure_data.custom_error",
                              "net::ERR_CONNECTION_RESET"));
   EXPECT_TRUE(HasBooleanValue(*entry, "network_changed", false));
   EXPECT_TRUE(HasStringValue(*entry, "protocol", "HTTP"));
   EXPECT_TRUE(HasBooleanValue(*entry, "quic_broken", true));
+  EXPECT_TRUE(HasBooleanValue(*entry, "quic_port_migration_detected", true));
   // N.B.: Assumes max_delay is 5 minutes.
   EXPECT_TRUE(HasIntegerValue(*entry, "request_age_ms", 300250));
   EXPECT_TRUE(HasIntegerValue(*entry, "request_elapsed_ms", 250));
   EXPECT_TRUE(HasDoubleValue(*entry, "sample_rate", 1.0));
   EXPECT_TRUE(HasStringValue(*entry, "server_ip", "127.0.0.1"));
   EXPECT_TRUE(HasStringValue(*entry, "status", "tcp.connection_reset"));
   EXPECT_TRUE(HasStringValue(*entry, "url", "https://localhost/"));
   EXPECT_TRUE(HasBooleanValue(*entry, "was_proxied", false));
 
   DomainReliabilityUploader::UploadResult result;
@@ skipping 28 matching lines @@
   CallUploadCallback(result);
 
   EXPECT_TRUE(CheckNoBeacons());
 }
 
 // Always expecting granular QUIC errors if status is quic.protocol error.
 TEST_F(DomainReliabilityContextTest,
        ReportUploadWithQuicProtocolErrorAndQuicError) {
   InitContext(MakeTestConfig());
   context_->OnBeacon(MakeCustomizedBeacon(&time_, "quic.protocol",
-                                          "quic.invalid.stream_data"));
+                                          "quic.invalid.stream_data", true));
 
   BeaconVector beacons;
   context_->GetQueuedBeaconsForTesting(&beacons);
   EXPECT_EQ(1u, beacons.size());
 
   time_.Advance(max_delay());
   EXPECT_TRUE(upload_pending());
   EXPECT_EQ(0, upload_max_depth());
   EXPECT_EQ(GURL("https://exampleuploader/upload"), upload_url());
 
   scoped_ptr<Value> value = base::JSONReader::Read(upload_report());
   const DictionaryValue* entry;
   ASSERT_TRUE(GetEntryFromReport(value.get(), 0, &entry));
 
   EXPECT_TRUE(HasBooleanValue(*entry, "quic_broken", true));
+  EXPECT_TRUE(HasBooleanValue(*entry, "quic_port_migration_detected", true));
   EXPECT_TRUE(HasStringValue(*entry, "status", "quic.protocol"));
   EXPECT_TRUE(HasStringValue(*entry, "quic_error", "quic.invalid.stream_data"));
 
   DomainReliabilityUploader::UploadResult result;
   result.status = DomainReliabilityUploader::UploadResult::SUCCESS;
   CallUploadCallback(result);
 
   EXPECT_TRUE(CheckNoBeacons());
 }
 
@@ skipping 26 matching lines @@
   EXPECT_TRUE(CheckNoBeacons());
 }
 
 // Edge cases that a non-QUIC protocol error with granular QUIC error reported,
 // probably indicating state machine in http_network_transaction is working
 // in a different way.
 TEST_F(DomainReliabilityContextTest,
        ReportUploadWithNonQuicProtocolErrorAndQuicError) {
   InitContext(MakeTestConfig());
   context_->OnBeacon(MakeCustomizedBeacon(&time_, "tcp.connection_reset",
-                                          "quic.invalid.stream_data"));
+                                          "quic.invalid.stream_data", false));
 
   BeaconVector beacons;
   context_->GetQueuedBeaconsForTesting(&beacons);
   EXPECT_EQ(1u, beacons.size());
 
   time_.Advance(max_delay());
   EXPECT_TRUE(upload_pending());
   EXPECT_EQ(0, upload_max_depth());
   EXPECT_EQ(GURL("https://exampleuploader/upload"), upload_url());
 
@@ skipping 129 matching lines @@
   beacon->chrome_error = net::OK;
   context_->OnBeacon(std::move(beacon));
   context_->GetQueuedBeaconsForTesting(&beacons);
   EXPECT_EQ(0u, beacons.size());
 }
 
 // TODO(ttuttle): Add beacon_unittest.cc to test serialization.
 
 }  // namespace
 }  // namespace domain_reliability