BASELINE: Update Chromium to 72.0.3626.110 and Ninja to 1.9.0

Change-Id: Ic57220b00ecc929a893c91f5cc552f5d3e99e922
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

5 files changed, 211 insertions, 39 deletions

diff --git a/chromium/net/network_error_logging/network_error_logging_service.cc b/chromium/net/network_error_logging/network_error_logging_service.cc
index 2981e70e205..5aacee3f271 100644
--- a/chromium/net/network_error_logging/network_error_logging_service.cc
+++ b/chromium/net/network_error_logging/network_error_logging_service.cc
@@ -113,50 +113,28 @@ const struct {
     // TODO(juliatuttle): Surely there are more errors we want here.
 };
 
-bool GetPhaseAndTypeFromNetError(Error error,
+void GetPhaseAndTypeFromNetError(Error error,
                                  std::string* phase_out,
                                  std::string* type_out) {
   for (size_t i = 0; i < arraysize(kErrorTypes); ++i) {
     if (kErrorTypes[i].error == error) {
       *phase_out = kErrorTypes[i].phase;
       *type_out = kErrorTypes[i].type;
-      return true;
+      return;
     }
   }
-  return false;
+  *phase_out = IsCertificateError(error) ? kConnectionPhase : kApplicationPhase;
+  *type_out = "unknown";
 }
 
 bool IsHttpError(const NetworkErrorLoggingService::RequestDetails& request) {
   return request.status_code >= 400 && request.status_code < 600;
 }
 
-enum class HeaderOutcome {
-  DISCARDED_NO_NETWORK_ERROR_LOGGING_SERVICE = 0,
-  DISCARDED_INVALID_SSL_INFO = 1,
-  DISCARDED_CERT_STATUS_ERROR = 2,
-
-  DISCARDED_INSECURE_ORIGIN = 3,
-
-  DISCARDED_JSON_TOO_BIG = 4,
-  DISCARDED_JSON_INVALID = 5,
-  DISCARDED_NOT_DICTIONARY = 6,
-  DISCARDED_TTL_MISSING = 7,
-  DISCARDED_TTL_NOT_INTEGER = 8,
-  DISCARDED_TTL_NEGATIVE = 9,
-  DISCARDED_REPORT_TO_MISSING = 10,
-  DISCARDED_REPORT_TO_NOT_STRING = 11,
-
-  REMOVED = 12,
-  SET = 13,
-
-  DISCARDED_MISSING_REMOTE_ENDPOINT = 14,
-
-  MAX
-};
-
-void RecordHeaderOutcome(HeaderOutcome outcome) {
-  UMA_HISTOGRAM_ENUMERATION("Net.NetworkErrorLogging.HeaderOutcome", outcome,
-                            HeaderOutcome::MAX);
+void RecordHeaderOutcome(NetworkErrorLoggingService::HeaderOutcome outcome) {
+  UMA_HISTOGRAM_ENUMERATION(NetworkErrorLoggingService::kHeaderOutcomeHistogram,
+                            outcome,
+                            NetworkErrorLoggingService::HeaderOutcome::MAX);
 }
 
 enum class RequestOutcome {
@@ -220,6 +198,7 @@ class NetworkErrorLoggingServiceImpl : public NetworkErrorLoggingService {
     if (policy.expires.is_null())
       return;
 
+    DVLOG(1) << "Received NEL policy for " << origin;
     auto inserted = policies_.insert(std::make_pair(origin, policy));
     DCHECK(inserted.second);
     MaybeAddWildcardPolicy(origin, &inserted.first->second);
@@ -260,10 +239,7 @@ class NetworkErrorLoggingServiceImpl : public NetworkErrorLoggingService {
 
     std::string phase_string;
     std::string type_string;
-    if (!GetPhaseAndTypeFromNetError(type, &phase_string, &type_string)) {
-      RecordRequestOutcome(RequestOutcome::DISCARDED_UNMAPPED_ERROR);
-      return;
-    }
+    GetPhaseAndTypeFromNetError(type, &phase_string, &type_string);
 
     if (IsHttpError(details)) {
       phase_string = kApplicationPhase;
@@ -308,6 +284,10 @@ class NetworkErrorLoggingServiceImpl : public NetworkErrorLoggingService {
       return;
     }
 
+    DVLOG(1) << "Created NEL report (" << type_string
+             << ", status=" << details.status_code
+             << ", depth=" << details.reporting_upload_depth << ") for "
+             << details.uri;
     reporting_service_->QueueReport(
         details.uri, details.user_agent, policy->report_to, kReportType,
         CreateReportBody(phase_string, type_string, sampling_fraction, details),
@@ -578,6 +558,10 @@ const char NetworkErrorLoggingService::kHeaderName[] = "NEL";
 
 const char NetworkErrorLoggingService::kReportType[] = "network-error";
 
+// static
+const char NetworkErrorLoggingService::kHeaderOutcomeHistogram[] =
+    "Net.NetworkErrorLogging.HeaderOutcome";
+
 // Allow NEL reports on regular requests, plus NEL reports on Reporting uploads
 // containing only regular requests, but do not allow NEL reports on Reporting
 // uploads containing Reporting uploads.
diff --git a/chromium/net/network_error_logging/network_error_logging_service.h b/chromium/net/network_error_logging/network_error_logging_service.h
index 058c0ad293d..87456134a7d 100644
--- a/chromium/net/network_error_logging/network_error_logging_service.h
+++ b/chromium/net/network_error_logging/network_error_logging_service.h
@@ -89,6 +89,35 @@ class NET_EXPORT NetworkErrorLoggingService {
   static const char kPhaseKey[];
   static const char kTypeKey[];
 
+  // Histograms.  These are mainly used in test cases to verify that interesting
+  // events occurred.
+
+  static const char kHeaderOutcomeHistogram[];
+
+  enum class HeaderOutcome {
+    DISCARDED_NO_NETWORK_ERROR_LOGGING_SERVICE = 0,
+    DISCARDED_INVALID_SSL_INFO = 1,
+    DISCARDED_CERT_STATUS_ERROR = 2,
+
+    DISCARDED_INSECURE_ORIGIN = 3,
+
+    DISCARDED_JSON_TOO_BIG = 4,
+    DISCARDED_JSON_INVALID = 5,
+    DISCARDED_NOT_DICTIONARY = 6,
+    DISCARDED_TTL_MISSING = 7,
+    DISCARDED_TTL_NOT_INTEGER = 8,
+    DISCARDED_TTL_NEGATIVE = 9,
+    DISCARDED_REPORT_TO_MISSING = 10,
+    DISCARDED_REPORT_TO_NOT_STRING = 11,
+
+    REMOVED = 12,
+    SET = 13,
+
+    DISCARDED_MISSING_REMOTE_ENDPOINT = 14,
+
+    MAX
+  };
+
   static void RecordHeaderDiscardedForNoNetworkErrorLoggingService();
   static void RecordHeaderDiscardedForInvalidSSLInfo();
   static void RecordHeaderDiscardedForCertStatusError();
diff --git a/chromium/net/network_error_logging/network_error_logging_service_unittest.cc b/chromium/net/network_error_logging/network_error_logging_service_unittest.cc
index 3f542c0a2e4..b9435544ff2 100644
--- a/chromium/net/network_error_logging/network_error_logging_service_unittest.cc
+++ b/chromium/net/network_error_logging/network_error_logging_service_unittest.cc
@@ -96,11 +96,6 @@ class TestReportingService : public ReportingService {
 
   void RemoveAllBrowsingData(int data_type_mask) override { NOTREACHED(); }
 
-  int GetUploadDepth(const URLRequest& request) override {
-    NOTREACHED();
-    return 0;
-  }
-
   const ReportingPolicy& GetPolicy() const override {
     NOTREACHED();
     return dummy_policy_;
@@ -327,6 +322,43 @@ TEST_F(NetworkErrorLoggingServiceTest, FailureReportQueued) {
                               NetworkErrorLoggingService::kTypeKey);
 }
 
+TEST_F(NetworkErrorLoggingServiceTest, UnknownFailureReportQueued) {
+  static const std::string kHeaderFailureFraction1 =
+      "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
+  service()->OnHeader(kOrigin_, kServerIP_, kHeaderFailureFraction1);
+
+  // This error code happens to not be mapped to a NEL report `type` field
+  // value.
+  service()->OnRequest(MakeRequestDetails(kUrl_, ERR_FILE_NO_SPACE));
+
+  ASSERT_EQ(1u, reports().size());
+  const base::DictionaryValue* body;
+  ASSERT_TRUE(reports()[0].body->GetAsDictionary(&body));
+  base::ExpectDictStringValue("application", *body,
+                              NetworkErrorLoggingService::kPhaseKey);
+  base::ExpectDictStringValue("unknown", *body,
+                              NetworkErrorLoggingService::kTypeKey);
+}
+
+TEST_F(NetworkErrorLoggingServiceTest, UnknownCertFailureReportQueued) {
+  static const std::string kHeaderFailureFraction1 =
+      "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
+  service()->OnHeader(kOrigin_, kServerIP_, kHeaderFailureFraction1);
+
+  // This error code happens to not be mapped to a NEL report `type` field
+  // value.  Because it's a certificate error, we'll set the `phase` to be
+  // `connection`.
+  service()->OnRequest(MakeRequestDetails(kUrl_, ERR_CERT_NON_UNIQUE_NAME));
+
+  ASSERT_EQ(1u, reports().size());
+  const base::DictionaryValue* body;
+  ASSERT_TRUE(reports()[0].body->GetAsDictionary(&body));
+  base::ExpectDictStringValue("connection", *body,
+                              NetworkErrorLoggingService::kPhaseKey);
+  base::ExpectDictStringValue("unknown", *body,
+                              NetworkErrorLoggingService::kTypeKey);
+}
+
 TEST_F(NetworkErrorLoggingServiceTest, HttpErrorReportQueued) {
   static const std::string kHeaderFailureFraction1 =
       "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
@@ -795,6 +827,17 @@ TEST_F(NetworkErrorLoggingServiceTest, StatusAsValue) {
   service()->OnHeader(kOrigin_, kServerIP_, kHeaderSuccessFraction1);
   service()->OnHeader(kOriginDifferentHost_, kServerIP_, kHeader_);
   service()->OnHeader(kOriginSubdomain_, kServerIP_, kHeaderIncludeSubdomains_);
+  const std::string kHeaderWrongTypes =
+      ("{\"report_to\":\"group\","
+       "\"max_age\":86400,"
+       // We'll ignore each of these fields because they're the wrong type.
+       // We'll use a default value instead.
+       "\"include_subdomains\":\"true\","
+       "\"success_fraction\": \"1.0\","
+       "\"failure_fraction\": \"0.0\"}");
+  service()->OnHeader(
+      url::Origin::Create(GURL("https://invalid-types.example.com")),
+      kServerIP_, kHeaderWrongTypes);
 
   base::Value actual = service()->StatusAsValue();
   std::unique_ptr<base::Value> expected = base::test::ParseJson(R"json(
@@ -817,6 +860,14 @@ TEST_F(NetworkErrorLoggingServiceTest, StatusAsValue) {
             "failureFraction": 1.0,
           },
           {
+            "origin": "https://invalid-types.example.com",
+            "includeSubdomains": false,
+            "expires": "86400000",
+            "reportTo": "group",
+            "successFraction": 0.0,
+            "failureFraction": 1.0,
+          },
+          {
             "origin": "https://subdomain.example.com",
             "includeSubdomains": true,
             "expires": "86400000",
diff --git a/chromium/net/network_error_logging/network_error_logging_test_util.cc b/chromium/net/network_error_logging/network_error_logging_test_util.cc
new file mode 100644
index 00000000000..d4d2a526419
--- /dev/null
+++ b/chromium/net/network_error_logging/network_error_logging_test_util.cc
@@ -0,0 +1,46 @@
+// Copyright 2018 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 "net/network_error_logging/network_error_logging_test_util.h"
+
+#include <algorithm>
+
+namespace net {
+
+TestNetworkErrorLoggingService::TestNetworkErrorLoggingService() = default;
+TestNetworkErrorLoggingService::~TestNetworkErrorLoggingService() = default;
+
+void TestNetworkErrorLoggingService::OnHeader(
+    const url::Origin& origin,
+    const IPAddress& received_ip_address,
+    const std::string& value) {
+  VLOG(1) << "Received NEL policy for " << origin;
+  Header header;
+  header.origin = origin;
+  header.received_ip_address = received_ip_address;
+  header.value = value;
+  headers_.push_back(header);
+}
+
+void TestNetworkErrorLoggingService::OnRequest(RequestDetails details) {
+  VLOG(1) << "Created NEL report (status=" << details.status_code
+          << ", depth=" << details.reporting_upload_depth << ") for "
+          << details.uri;
+  errors_.push_back(std::move(details));
+}
+
+void TestNetworkErrorLoggingService::RemoveBrowsingData(
+    const base::RepeatingCallback<bool(const GURL&)>& origin_filter) {}
+
+void TestNetworkErrorLoggingService::RemoveAllBrowsingData() {}
+
+bool TestNetworkErrorLoggingService::Header::MatchesAddressList(
+    const AddressList& address_list) const {
+  return std::any_of(address_list.begin(), address_list.end(),
+                     [this](const IPEndPoint& endpoint) {
+                       return endpoint.address() == received_ip_address;
+                     });
+}
+
+}  // namespace net
diff --git a/chromium/net/network_error_logging/network_error_logging_test_util.h b/chromium/net/network_error_logging/network_error_logging_test_util.h
new file mode 100644
index 00000000000..9f46d13b5b0
--- /dev/null
+++ b/chromium/net/network_error_logging/network_error_logging_test_util.h
@@ -0,0 +1,62 @@
+// Copyright 2018 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.
+
+#ifndef NET_NETWORK_ERROR_LOGGING_NETWORK_ERROR_LOGGING_TEST_UTIL_H_
+#define NET_NETWORK_ERROR_LOGGING_NETWORK_ERROR_LOGGING_TEST_UTIL_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "net/base/address_list.h"
+#include "net/base/ip_address.h"
+#include "net/network_error_logging/network_error_logging_service.h"
+#include "url/gurl.h"
+#include "url/origin.h"
+
+namespace net {
+
+// A NetworkErrorLoggingService implementation that stashes all NEL headers and
+// reports so that they can be easily verified in unit tests.
+class TestNetworkErrorLoggingService : public NetworkErrorLoggingService {
+ public:
+  struct Header {
+    Header() = default;
+    ~Header() = default;
+
+    // Returns whether the |received_ip_address| field matches any of the
+    // addresses in |address_list|.
+    bool MatchesAddressList(const AddressList& address_list) const;
+
+    url::Origin origin;
+    IPAddress received_ip_address;
+    std::string value;
+  };
+
+  TestNetworkErrorLoggingService();
+  ~TestNetworkErrorLoggingService() override;
+
+  const std::vector<Header>& headers() { return headers_; }
+  const std::vector<RequestDetails>& errors() { return errors_; }
+
+  // NetworkErrorLoggingService implementation
+  void OnHeader(const url::Origin& origin,
+                const IPAddress& received_ip_address,
+                const std::string& value) override;
+  void OnRequest(RequestDetails details) override;
+  void RemoveBrowsingData(
+      const base::RepeatingCallback<bool(const GURL&)>& origin_filter) override;
+  void RemoveAllBrowsingData() override;
+
+ private:
+  std::vector<Header> headers_;
+  std::vector<RequestDetails> errors_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestNetworkErrorLoggingService);
+};
+
+}  // namespace net
+
+#endif  // NET_NETWORK_ERROR_LOGGING_NETWORK_ERROR_LOGGING_TEST_UTIL_H_