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>

1 files changed, 115 insertions, 0 deletions

diff --git a/chromium/services/network/network_qualities_pref_delegate.cc b/chromium/services/network/network_qualities_pref_delegate.cc
new file mode 100644
index 00000000000..7f87fb9df11
--- /dev/null
+++ b/chromium/services/network/network_qualities_pref_delegate.cc
@@ -0,0 +1,115 @@
+// 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 "services/network/network_qualities_pref_delegate.h"
+
+#include <memory>
+#include <string>
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/values.h"
+#include "components/prefs/pref_registry.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
+#include "net/nqe/network_quality_estimator.h"
+
+namespace {
+
+// Prefs for persisting network qualities.
+const char kNetworkQualities[] = "net.network_qualities";
+
+// PrefDelegateImpl writes the provided dictionary value to the network quality
+// estimator prefs on the disk.
+class PrefDelegateImpl
+    : public net::NetworkQualitiesPrefsManager::PrefDelegate {
+ public:
+  // |pref_service| is used to read and write prefs from/to the disk.
+  explicit PrefDelegateImpl(PrefService* pref_service)
+      : pref_service_(pref_service), path_(kNetworkQualities) {
+    DCHECK(pref_service_);
+  }
+  ~PrefDelegateImpl() override {}
+
+  void SetDictionaryValue(const base::DictionaryValue& value) override {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    pref_service_->Set(path_, value);
+    UMA_HISTOGRAM_EXACT_LINEAR("NQE.Prefs.WriteCount", 1, 2);
+  }
+
+  std::unique_ptr<base::DictionaryValue> GetDictionaryValue() override {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+    UMA_HISTOGRAM_EXACT_LINEAR("NQE.Prefs.ReadCount", 1, 2);
+    return pref_service_->GetDictionary(path_)->CreateDeepCopy();
+  }
+
+ private:
+  PrefService* pref_service_;
+
+  // |path_| is the location of the network quality estimator prefs.
+  const std::string path_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
+  DISALLOW_COPY_AND_ASSIGN(PrefDelegateImpl);
+};
+
+// Returns true if |pref_service| has been initialized.
+bool IsPrefServiceInitialized(PrefService* pref_service) {
+  return pref_service->GetInitializationStatus() !=
+         PrefService::INITIALIZATION_STATUS_WAITING;
+}
+
+}  // namespace
+
+namespace network {
+
+NetworkQualitiesPrefDelegate::NetworkQualitiesPrefDelegate(
+    PrefService* pref_service,
+    net::NetworkQualityEstimator* network_quality_estimator)
+    : prefs_manager_(std::make_unique<PrefDelegateImpl>(pref_service)),
+      network_quality_estimator_(network_quality_estimator),
+      weak_ptr_factory_(this) {
+  DCHECK(pref_service);
+  DCHECK(network_quality_estimator_);
+
+  if (IsPrefServiceInitialized(pref_service)) {
+    OnPrefServiceInitialized(true);
+  } else {
+    // Register for a callback that will be invoked when |pref_service| is
+    // initialized.
+    pref_service->AddPrefInitObserver(
+        base::BindOnce(&NetworkQualitiesPrefDelegate::OnPrefServiceInitialized,
+                       weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+NetworkQualitiesPrefDelegate::~NetworkQualitiesPrefDelegate() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+void NetworkQualitiesPrefDelegate::OnPrefServiceInitialized(bool success) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  prefs_manager_.InitializeOnNetworkThread(network_quality_estimator_);
+}
+
+void NetworkQualitiesPrefDelegate::ClearPrefs() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  prefs_manager_.ClearPrefs();
+}
+
+// static
+void NetworkQualitiesPrefDelegate::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(kNetworkQualities);
+}
+
+std::map<net::nqe::internal::NetworkID,
+         net::nqe::internal::CachedNetworkQuality>
+NetworkQualitiesPrefDelegate::ForceReadPrefsForTesting() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return prefs_manager_.ForceReadPrefsForTesting();
+}
+
+}  // namespace network