BASELINE: Update Chromium to 65.0.3525.40

Also imports missing submodules

Change-Id: I36901b7c6a325cda3d2c10cedb2186c25af3b79b
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

37 files changed, 733 insertions, 270 deletions

diff --git a/chromium/chrome/browser/ui/webui/settings/DEPS b/chromium/chrome/browser/ui/webui/settings/DEPS
deleted file mode 100644
index 72e2db9373b..00000000000
--- a/chromium/chrome/browser/ui/webui/settings/DEPS
+++ /dev/null
@@ -1,4 +0,0 @@
-include_rules = [
-  # TODO(mash): Remove. http://crbug.com/644348
-  "+ash/system/power",
-]
diff --git a/chromium/chrome/browser/ui/webui/settings/about_handler.cc b/chromium/chrome/browser/ui/webui/settings/about_handler.cc
index f5bce72f8e9..1920f85c03a 100644
--- a/chromium/chrome/browser/ui/webui/settings/about_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/about_handler.cc
@@ -16,7 +16,6 @@
 #include "base/i18n/message_formatter.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -637,9 +636,9 @@ void AboutHandler::SetUpdateStatus(VersionUpdater::Status status,
     if (!types_msg.empty())
       event->SetString("connectionTypes", types_msg);
     else
-      event->Set("connectionTypes", base::MakeUnique<base::Value>());
+      event->Set("connectionTypes", std::make_unique<base::Value>());
   } else {
-    event->Set("connectionTypes", base::MakeUnique<base::Value>());
+    event->Set("connectionTypes", std::make_unique<base::Value>());
   }
 #endif  // defined(OS_CHROMEOS)
 
diff --git a/chromium/chrome/browser/ui/webui/settings/browser_lifetime_handler.cc b/chromium/chrome/browser/ui/webui/settings/browser_lifetime_handler.cc
index 477aa793415..3c264c536a0 100644
--- a/chromium/chrome/browser/ui/webui/settings/browser_lifetime_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/browser_lifetime_handler.cc
@@ -12,6 +12,7 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
+#include "chrome/browser/chromeos/tpm_firmware_update.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/user_manager/user_manager.h"
@@ -58,6 +59,24 @@ void BrowserLifetimeHandler::HandleSignOutAndRestart(
 
 void BrowserLifetimeHandler::HandleFactoryReset(
     const base::ListValue* args) {
+  bool tpm_firmware_update_requested;
+  args->GetBoolean(0, &tpm_firmware_update_requested);
+  if (tpm_firmware_update_requested) {
+    chromeos::tpm_firmware_update::ShouldOfferUpdateViaPowerwash(
+        base::BindOnce([](bool offer_update) {
+          if (!offer_update)
+            return;
+
+          PrefService* prefs = g_browser_process->local_state();
+          prefs->SetBoolean(prefs::kFactoryResetRequested, true);
+          prefs->SetBoolean(prefs::kFactoryResetTPMFirmwareUpdateRequested,
+                            true);
+          prefs->CommitPendingWrite();
+          chrome::AttemptRelaunch();
+        }));
+    return;
+  }
+
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   bool allow_powerwash = !connector->IsEnterpriseManaged() &&
diff --git a/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.cc b/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.cc
index c7174d08712..fa100c69aa3 100644
--- a/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/ui/webui/settings/chrome_cleanup_handler.h"
 
+#include <memory>
 #include <string>
 
 #include "base/command_line.h"
@@ -13,9 +14,16 @@
 #include "base/metrics/user_metrics_action.h"
 #include "base/synchronization/lock.h"
 #include "base/values.h"
+#include "build/build_config.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_field_trial_win.h"
+#include "chrome/grit/generated_resources.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
+#include "content/public/browser/web_ui_message_handler.h"
+#include "ui/base/l10n/l10n_util.h"
 
 using safe_browsing::ChromeCleanerController;
 
@@ -33,19 +41,45 @@ enum ChromeCleanerDismissSource {
 };
 
 // Returns a ListValue containing a copy of the file paths stored in |files|.
-base::ListValue GetFilesAsListStorage(const std::set<base::FilePath>& files) {
-  base::ListValue value;
+std::unique_ptr<base::ListValue> GetFilesAsListStorage(
+    const std::set<base::FilePath>& files) {
+  auto value = std::make_unique<base::ListValue>();
   for (const base::FilePath& path : files)
-    value.AppendString(path.value());
+    value->AppendString(path.value());
 
   return value;
 }
 
+// Returns a ListValue containing a copy of the registry keys stored in
+// |registry_keys|.
+std::unique_ptr<base::ListValue> GetRegistryKeysAsListStorage(
+    const std::set<base::string16>& registry_keys) {
+  auto value = std::make_unique<base::ListValue>();
+  for (const base::string16& key : registry_keys)
+    value->AppendString(key);
+
+  return value;
+}
+
+base::DictionaryValue GetScannerResultsAsDictionary(
+    const safe_browsing::ChromeCleanerScannerResults& scanner_results) {
+  base::DictionaryValue value;
+  value.SetList("files",
+                GetFilesAsListStorage(scanner_results.files_to_delete()));
+  value.SetList("registryKeys",
+                GetRegistryKeysAsListStorage(scanner_results.registry_keys()));
+  return value;
+}
+
 std::string IdleReasonToString(
     ChromeCleanerController::IdleReason idle_reason) {
   switch (idle_reason) {
     case ChromeCleanerController::IdleReason::kInitial:
       return "initial";
+    case ChromeCleanerController::IdleReason::kReporterFoundNothing:
+      return "reporter_found_nothing";
+    case ChromeCleanerController::IdleReason::kReporterFailed:
+      return "reporter_failed";
     case ChromeCleanerController::IdleReason::kScanningFoundNothing:
       return "scanning_found_nothing";
     case ChromeCleanerController::IdleReason::kScanningFailed:
@@ -58,6 +92,8 @@ std::string IdleReasonToString(
       return "cleaning_failed";
     case ChromeCleanerController::IdleReason::kCleaningSucceeded:
       return "cleaning_succeeded";
+    case ChromeCleanerController::IdleReason::kCleanerDownloadFailed:
+      return "cleaner_download_failed";
   }
   NOTREACHED();
   return "";
@@ -75,31 +111,47 @@ ChromeCleanupHandler::~ChromeCleanupHandler() {
 void ChromeCleanupHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "dismissCleanupPage",
-      base::Bind(&ChromeCleanupHandler::HandleDismiss, base::Unretained(this)));
+      base::BindRepeating(&ChromeCleanupHandler::HandleDismiss,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "registerChromeCleanerObserver",
-      base::Bind(&ChromeCleanupHandler::HandleRegisterChromeCleanerObserver,
-                 base::Unretained(this)));
+      base::BindRepeating(
+          &ChromeCleanupHandler::HandleRegisterChromeCleanerObserver,
+          base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "startScanning",
+      base::BindRepeating(&ChromeCleanupHandler::HandleStartScanning,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "restartComputer",
-      base::Bind(&ChromeCleanupHandler::HandleRestartComputer,
-                 base::Unretained(this)));
+      base::BindRepeating(&ChromeCleanupHandler::HandleRestartComputer,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "setLogsUploadPermission",
-      base::Bind(&ChromeCleanupHandler::HandleSetLogsUploadPermission,
-                 base::Unretained(this)));
+      base::BindRepeating(&ChromeCleanupHandler::HandleSetLogsUploadPermission,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
-      "startCleanup", base::Bind(&ChromeCleanupHandler::HandleStartCleanup,
-                                 base::Unretained(this)));
+      "startCleanup",
+      base::BindRepeating(&ChromeCleanupHandler::HandleStartCleanup,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "notifyShowDetails",
-      base::Bind(&ChromeCleanupHandler::HandleNotifyShowDetails,
-                 base::Unretained(this)));
+      base::BindRepeating(&ChromeCleanupHandler::HandleNotifyShowDetails,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "notifyChromeCleanupLearnMoreClicked",
-      base::Bind(
+      base::BindRepeating(
           &ChromeCleanupHandler::HandleNotifyChromeCleanupLearnMoreClicked,
           base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getMoreItemsPluralString",
+      base::BindRepeating(&ChromeCleanupHandler::HandleGetMoreItemsPluralString,
+                          base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getItemsToRemovePluralString",
+      base::BindRepeating(
+          &ChromeCleanupHandler::HandleGetItemsToRemovePluralString,
+          base::Unretained(this)));
 }
 
 void ChromeCleanupHandler::OnJavascriptAllowed() {
@@ -112,39 +164,41 @@ void ChromeCleanupHandler::OnJavascriptDisallowed() {
 
 void ChromeCleanupHandler::OnIdle(
     ChromeCleanerController::IdleReason idle_reason) {
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-idle"),
-                         base::Value(IdleReasonToString(idle_reason)));
+  FireWebUIListener("chrome-cleanup-on-idle",
+                    base::Value(IdleReasonToString(idle_reason)));
 }
 
 void ChromeCleanupHandler::OnScanning() {
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-scanning"));
+  FireWebUIListener("chrome-cleanup-on-scanning");
+}
+
+void ChromeCleanupHandler::OnReporterRunning() {
+  FireWebUIListener("chrome-cleanup-on-reporter-running");
 }
 
 void ChromeCleanupHandler::OnInfected(
+    bool is_powered_by_partner,
     const safe_browsing::ChromeCleanerScannerResults& scanner_results) {
-  CallJavascriptFunction(
-      "cr.webUIListenerCallback", base::Value("chrome-cleanup-on-infected"),
-      GetFilesAsListStorage(scanner_results.files_to_delete()));
+  FireWebUIListener("chrome-cleanup-on-infected",
+                    base::Value(is_powered_by_partner),
+                    GetScannerResultsAsDictionary(scanner_results));
 }
 
 void ChromeCleanupHandler::OnCleaning(
+    bool is_powered_by_partner,
     const safe_browsing::ChromeCleanerScannerResults& scanner_results) {
-  CallJavascriptFunction(
-      "cr.webUIListenerCallback", base::Value("chrome-cleanup-on-cleaning"),
-      GetFilesAsListStorage(scanner_results.files_to_delete()));
+  FireWebUIListener("chrome-cleanup-on-cleaning",
+                    base::Value(is_powered_by_partner),
+                    GetScannerResultsAsDictionary(scanner_results));
 }
 
 void ChromeCleanupHandler::OnRebootRequired() {
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-reboot-required"));
+  FireWebUIListener("chrome-cleanup-on-reboot-required");
 }
 
 void ChromeCleanupHandler::OnLogsEnabledChanged(bool logs_enabled) {
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-upload-permission-change"),
-                         base::Value(logs_enabled));
+  FireWebUIListener("chrome-cleanup-upload-permission-change",
+                    base::Value(logs_enabled));
 }
 
 void ChromeCleanupHandler::HandleDismiss(const base::ListValue* args) {
@@ -173,8 +227,7 @@ void ChromeCleanupHandler::HandleDismiss(const base::ListValue* args) {
   controller_->RemoveObserver(this);
   controller_->ResetIdleState();
 
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-dismiss"));
+  FireWebUIListener("chrome-cleanup-on-dismiss");
 }
 
 void ChromeCleanupHandler::HandleRegisterChromeCleanerObserver(
@@ -190,14 +243,27 @@ void ChromeCleanupHandler::HandleRegisterChromeCleanerObserver(
   OnLogsEnabledChanged(controller_->logs_enabled());
 }
 
+void ChromeCleanupHandler::HandleStartScanning(const base::ListValue* args) {
+  CHECK_EQ(1U, args->GetSize());
+  bool allow_logs_upload = false;
+  args->GetBoolean(0, &allow_logs_upload);
+
+  // The state is propagated to all open tabs and should be consistent.
+  DCHECK_EQ(controller_->logs_enabled(), allow_logs_upload);
+
+  controller_->RequestUserInitiatedScan();
+
+  base::RecordAction(
+      base::UserMetricsAction("SoftwareReporter.CleanupWebui_StartScanning"));
+}
+
 void ChromeCleanupHandler::HandleRestartComputer(const base::ListValue* args) {
   DCHECK_EQ(0U, args->GetSize());
 
   base::RecordAction(
       base::UserMetricsAction("SoftwareReporter.CleanupWebui_RestartComputer"));
 
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-dismiss"));
+  FireWebUIListener("chrome-cleanup-on-dismiss");
 
   controller_->Reboot();
 }
@@ -262,4 +328,34 @@ void ChromeCleanupHandler::HandleNotifyChromeCleanupLearnMoreClicked(
       base::UserMetricsAction("SoftwareReporter.CleanupWebui_LearnMore"));
 }
 
+void ChromeCleanupHandler::HandleGetMoreItemsPluralString(
+    const base::ListValue* args) {
+#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+  GetPluralString(IDS_SETTINGS_RESET_CLEANUP_DETAILS_MORE, args);
+#endif  // defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+}
+
+void ChromeCleanupHandler::HandleGetItemsToRemovePluralString(
+    const base::ListValue* args) {
+#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+  GetPluralString(IDS_SETTINGS_RESET_CLEANUP_DETAILS_ITEMS_TO_BE_REMOVED, args);
+#endif  // defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+}
+
+void ChromeCleanupHandler::GetPluralString(int id,
+                                           const base::ListValue* args) {
+  CHECK_EQ(2U, args->GetSize());
+
+  std::string callback_id;
+  CHECK(args->GetString(0, &callback_id));
+
+  int num_items = 0;
+  args->GetInteger(1, &num_items);
+  DCHECK_GT(0, num_items);
+
+  ResolveJavascriptCallback(
+      base::Value(callback_id),
+      base::Value(l10n_util::GetPluralStringFUTF16(id, num_items)));
+}
+
 }  // namespace settings
diff --git a/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.h b/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.h
index 1e3cf17387d..199ca791fe2 100644
--- a/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.h
+++ b/chromium/chrome/browser/ui/webui/settings/chrome_cleanup_handler.h
@@ -33,10 +33,13 @@ class ChromeCleanupHandler
   // ChromeCleanerController::Observer implementation.
   void OnIdle(
       safe_browsing::ChromeCleanerController::IdleReason idle_reason) override;
+  void OnReporterRunning() override;
   void OnScanning() override;
-  void OnInfected(const safe_browsing::ChromeCleanerScannerResults&
+  void OnInfected(bool is_powered_by_partner,
+                  const safe_browsing::ChromeCleanerScannerResults&
                       reported_results) override;
-  void OnCleaning(const safe_browsing::ChromeCleanerScannerResults&
+  void OnCleaning(bool is_powered_by_partner,
+                  const safe_browsing::ChromeCleanerScannerResults&
                       reported_results) override;
   void OnRebootRequired() override;
   void OnLogsEnabledChanged(bool logs_enabled) override;
@@ -51,6 +54,10 @@ class ChromeCleanupHandler
   // and retrieves the current cleanup state.
   void HandleRegisterChromeCleanerObserver(const base::ListValue* args);
 
+  // Callback for the "startScanning" message to start scanning the user's
+  // system to detect unwanted software.
+  void HandleStartScanning(const base::ListValue* args);
+
   // Callback for the "restartComputer" message to finalize the cleanup with a
   // system restart.
   void HandleRestartComputer(const base::ListValue* args);
@@ -71,6 +78,16 @@ class ChromeCleanupHandler
   // the "learn more" link was clicked.
   void HandleNotifyChromeCleanupLearnMoreClicked(const base::ListValue* args);
 
+  // Callback for the "getMoreItemsPluralString" message, that obtains the text
+  // string for the "show more" items on the detailed view.
+  void HandleGetMoreItemsPluralString(const base::ListValue* args);
+
+  // Callback for the "getItemsToRemovePluralString" message, that obtains the
+  // text string for the detailed view when user-initiated cleanups are enabled.
+  void HandleGetItemsToRemovePluralString(const base::ListValue* args);
+
+  void GetPluralString(int id, const base::ListValue* args);
+
   // Raw pointer to a singleton. Must outlive this object.
   safe_browsing::ChromeCleanerController* controller_;
 
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/DEPS b/chromium/chrome/browser/ui/webui/settings/chromeos/DEPS
new file mode 100644
index 00000000000..9f60b59abe3
--- /dev/null
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/DEPS
@@ -0,0 +1,6 @@
+specific_include_rules = {
+  "device_power_handler(|_unittest)\.(h|cc)": [
+    # TODO(mash): Remove. http://crbug.com/770866
+    "+ash/system/power/power_status.h",
+  ],
+}
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/change_picture_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/change_picture_handler.cc
index d12d82ebffa..6a345261eb0 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/change_picture_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/change_picture_handler.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/ui/webui/settings/chromeos/change_picture_handler.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/base64.h"
@@ -164,13 +165,13 @@ void ChangePictureHandler::HandleChooseFile(const base::ListValue* args) {
 void ChangePictureHandler::HandleDiscardPhoto(const base::ListValue* args) {
   DCHECK(args->empty());
   AccessibilityManager::Get()->PlayEarcon(
-      SOUND_OBJECT_DELETE, PlaySoundOption::SPOKEN_FEEDBACK_ENABLED);
+      SOUND_OBJECT_DELETE, PlaySoundOption::ONLY_IF_SPOKEN_FEEDBACK_ENABLED);
 }
 
 void ChangePictureHandler::HandlePhotoTaken(const base::ListValue* args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AccessibilityManager::Get()->PlayEarcon(
-      SOUND_CAMERA_SNAP, PlaySoundOption::SPOKEN_FEEDBACK_ENABLED);
+      SOUND_CAMERA_SNAP, PlaySoundOption::ONLY_IF_SPOKEN_FEEDBACK_ENABLED);
 
   std::string image_url;
   if (!args || args->GetSize() != 1 || !args->GetString(0, &image_url))
@@ -298,10 +299,16 @@ void ChangePictureHandler::HandleSelectImage(const base::ListValue* args) {
   if (image_type == "old") {
     // Previous image (from camera or manually uploaded) re-selected.
     DCHECK(!previous_image_.isNull());
-    std::unique_ptr<user_manager::UserImage> user_image =
-        base::MakeUnique<user_manager::UserImage>(
-            previous_image_, previous_image_bytes_, previous_image_format_);
-    user_image->MarkAsSafe();
+    std::unique_ptr<user_manager::UserImage> user_image;
+    if (previous_image_format_ == user_manager::UserImage::FORMAT_PNG &&
+        previous_image_bytes_) {
+      user_image = std::make_unique<user_manager::UserImage>(
+          previous_image_, previous_image_bytes_, previous_image_format_);
+      user_image->MarkAsSafe();
+    } else {
+      user_image = user_manager::UserImage::CreateAndEncode(
+          previous_image_, user_manager::UserImage::FORMAT_JPEG);
+    }
     user_image_manager->SaveUserImage(std::move(user_image));
 
     UMA_HISTOGRAM_EXACT_LINEAR("UserImage.ChangeChoice",
@@ -375,7 +382,7 @@ void ChangePictureHandler::SetImageFromCamera(
     const gfx::ImageSkia& photo,
     base::RefCountedBytes* photo_bytes) {
   std::unique_ptr<user_manager::UserImage> user_image =
-      base::MakeUnique<user_manager::UserImage>(
+      std::make_unique<user_manager::UserImage>(
           photo, photo_bytes, user_manager::UserImage::FORMAT_PNG);
   user_image->MarkAsSafe();
   ChromeUserManager::Get()
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc
index de59cbdc896..6d0cf18456f 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/cups_printers_handler.cc
@@ -11,7 +11,6 @@
 #include "base/files/file_util.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
@@ -83,7 +82,7 @@ void RecordIppQuerySuccess(bool success) {
   UMA_HISTOGRAM_BOOLEAN("Printing.CUPS.IppAttributesSuccess", success);
 }
 
-// Parsees |printer_uri| into its components and written into |uri|.  Returns
+// Parses |printer_uri| into its components and written into |uri|.  Returns
 // true if the uri was parsed successfully, returns false otherwise.  No changes
 // are made to |uri| if this function returns false.
 bool ParseUri(const std::string& printer_uri, PrinterUri* uri) {
@@ -153,7 +152,7 @@ void QueryAutoconf(const std::string& printer_uri,
 // definition of CupsPrinterInfo.
 std::unique_ptr<base::DictionaryValue> CreateEmptyPrinterInfo() {
   std::unique_ptr<base::DictionaryValue> printer_info =
-      base::MakeUnique<base::DictionaryValue>();
+      std::make_unique<base::DictionaryValue>();
   printer_info->SetString("ppdManufacturer", "");
   printer_info->SetString("ppdModel", "");
   printer_info->SetString("printerAddress", "");
@@ -181,9 +180,9 @@ std::string PrinterAddress(const std::string& host, int port) {
   return host;
 }
 
-// Returns a JSON representation of |printer| as a CupsPrinterInfo. Note it's
-// possible that this function returns a nullptr if the printer url is not in
-// the right format.
+// Returns a JSON representation of |printer| as a CupsPrinterInfo. If the
+// printer uri cannot be parsed, the relevant fields are populated with default
+// values.
 std::unique_ptr<base::DictionaryValue> GetPrinterInfo(const Printer& printer) {
   std::unique_ptr<base::DictionaryValue> printer_info =
       CreateEmptyPrinterInfo();
@@ -196,7 +195,13 @@ std::unique_ptr<base::DictionaryValue> GetPrinterInfo(const Printer& printer) {
 
   PrinterUri uri;
   if (!ParseUri(printer.uri(), &uri)) {
-    return nullptr;
+    // Uri is invalid so we set default values.
+    LOG(WARNING) << "Could not parse uri.  Defaulting values";
+    printer_info->SetString("printerAddress", "");
+    printer_info->SetString("printerQueue", "");
+    printer_info->SetString("printerProtocol",
+                            "ipp");  // IPP is our default protocol.
+    return printer_info;
   }
 
   if (base::ToLowerASCII(uri.scheme) == "usb") {
@@ -268,7 +273,7 @@ std::unique_ptr<chromeos::Printer> DictToPrinter(
     printer_uri += "/" + printer_queue;
   }
 
-  auto printer = base::MakeUnique<chromeos::Printer>(printer_id);
+  auto printer = std::make_unique<chromeos::Printer>(printer_id);
   printer->set_display_name(printer_name);
   printer->set_description(printer_description);
   printer->set_manufacturer(printer_manufacturer);
@@ -361,16 +366,14 @@ void CupsPrintersHandler::HandleGetCupsPrintersList(
   std::vector<Printer> printers =
       printers_manager_->GetPrinters(CupsPrintersManager::kConfigured);
 
-  auto printers_list = base::MakeUnique<base::ListValue>();
+  auto printers_list = std::make_unique<base::ListValue>();
   for (const Printer& printer : printers) {
-    // TODO(skau): Theoretically |printer_info| should not be a nullptr as we
-    // should not allow adding an invalid configured printer to PrinterManager.
-    auto printer_info = GetPrinterInfo(printer);
-    if (printer_info)
-      printers_list->Append(std::move(printer_info));
+    // Some of these printers could be invalid but we want to allow the user
+    // to edit them. crbug.com/778383
+    printers_list->Append(GetPrinterInfo(printer));
   }
 
-  auto response = base::MakeUnique<base::DictionaryValue>();
+  auto response = std::make_unique<base::DictionaryValue>();
   response->Set("printerList", std::move(printers_list));
   ResolveJavascriptCallback(base::Value(callback_id), *response);
 }
@@ -567,8 +570,8 @@ void CupsPrintersHandler::HandleAddCupsPrinter(const base::ListValue* args) {
     // model.
     bool found = false;
     for (const auto& resolved_printer : resolved_printers_[ppd_manufacturer]) {
-      if (resolved_printer.first == ppd_model) {
-        *printer->mutable_ppd_reference() = resolved_printer.second;
+      if (resolved_printer.name == ppd_model) {
+        *(printer->mutable_ppd_reference()) = resolved_printer.ppd_ref;
         found = true;
         break;
       }
@@ -690,7 +693,7 @@ void CupsPrintersHandler::HandleGetCupsPrinterModels(
   if (manufacturer.empty()) {
     base::DictionaryValue response;
     response.SetBoolean("success", true);
-    response.Set("models", base::MakeUnique<base::ListValue>());
+    response.Set("models", std::make_unique<base::ListValue>());
     ResolveJavascriptCallback(base::Value(js_callback), response);
     return;
   }
@@ -726,7 +729,7 @@ void CupsPrintersHandler::ResolveManufacturersDone(
     const std::string& js_callback,
     PpdProvider::CallbackResultCode result_code,
     const std::vector<std::string>& manufacturers) {
-  auto manufacturers_value = base::MakeUnique<base::ListValue>();
+  auto manufacturers_value = std::make_unique<base::ListValue>();
   if (result_code == PpdProvider::SUCCESS) {
     manufacturers_value->AppendStrings(manufacturers);
   }
@@ -741,11 +744,11 @@ void CupsPrintersHandler::ResolvePrintersDone(
     const std::string& js_callback,
     PpdProvider::CallbackResultCode result_code,
     const PpdProvider::ResolvedPrintersList& printers) {
-  auto printers_value = base::MakeUnique<base::ListValue>();
+  auto printers_value = std::make_unique<base::ListValue>();
   if (result_code == PpdProvider::SUCCESS) {
     resolved_printers_[manufacturer] = printers;
     for (const auto& printer : printers) {
-      printers_value->AppendString(printer.first);
+      printers_value->AppendString(printer.name);
     }
   }
   base::DictionaryValue response;
@@ -814,16 +817,12 @@ void CupsPrintersHandler::OnPrintersChanged(
       return;
   }
   std::unique_ptr<base::ListValue> printers_list =
-      base::MakeUnique<base::ListValue>();
+      std::make_unique<base::ListValue>();
   for (const Printer& printer : automatic_printers_) {
-    auto printer_info = GetPrinterInfo(printer);
-    if (printer_info)
-      printers_list->Append(std::move(printer_info));
+    printers_list->Append(GetPrinterInfo(printer));
   }
   for (const Printer& printer : discovered_printers_) {
-    auto printer_info = GetPrinterInfo(printer);
-    if (printer_info)
-      printers_list->Append(std::move(printer_info));
+    printers_list->Append(GetPrinterInfo(printer));
   }
 
   FireWebUIListener("on-printer-discovered", *printers_list);
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/date_time_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/date_time_handler.cc
index 00dbac60749..ffe094e20ee 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/date_time_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/date_time_handler.cc
@@ -83,13 +83,6 @@ DateTimeHandler* DateTimeHandler::Create(
       "timeZoneID",
       system::TimezoneSettings::GetInstance()->GetCurrentTimezoneID());
 
-  if (!IsTimezoneAutomaticDetectionUserEditable()) {
-    html_source->AddBoolean("timeZoneAutoDetectValueFromPolicy",
-                            g_browser_process->platform_part()
-                                ->GetTimezoneResolverManager()
-                                ->ShouldApplyResolvedTimezone());
-  }
-
   return new DateTimeHandler;
 }
 
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/device_keyboard_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/device_keyboard_handler_unittest.cc
index 7d837497c67..bbf2fa12df1 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/device_keyboard_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/device_keyboard_handler_unittest.cc
@@ -13,9 +13,9 @@
 #include "base/observer_list.h"
 #include "chromeos/chromeos_switches.h"
 #include "content/public/test/test_web_ui.h"
+#include "services/ui/public/cpp/input_devices/input_device_client_test_api.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/devices/input_device.h"
-#include "ui/events/test/device_data_manager_test_api.h"
 
 namespace chromeos {
 namespace settings {
@@ -38,7 +38,7 @@ class KeyboardHandlerTest : public testing::Test {
     handler_.AllowJavascriptForTesting();
 
     // Make sure that we start out without any keyboards reported.
-    device_test_api_.SetKeyboardDevices(std::vector<ui::InputDevice>());
+    input_device_client_test_api_.SetKeyboardDevices({});
   }
 
  protected:
@@ -87,7 +87,7 @@ class KeyboardHandlerTest : public testing::Test {
     return has_diamond_key;
   }
 
-  ui::test::DeviceDataManagerTestAPI device_test_api_;
+  ui::InputDeviceClientTestApi input_device_client_test_api_;
   content::TestWebUI web_ui_;
   TestKeyboardHandler handler_;
   KeyboardHandler::TestAPI handler_test_api_;
@@ -116,7 +116,7 @@ TEST_F(KeyboardHandlerTest, ExternalKeyboard) {
   // An internal keyboard shouldn't change the defaults.
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       chromeos::switches::kHasChromeOSKeyboard);
-  device_test_api_.SetKeyboardDevices(std::vector<ui::InputDevice>{
+  input_device_client_test_api_.SetKeyboardDevices(std::vector<ui::InputDevice>{
       {1, ui::INPUT_DEVICE_INTERNAL, "internal keyboard"}});
   handler_test_api_.Initialize();
   EXPECT_FALSE(HasCapsLock());
@@ -124,15 +124,13 @@ TEST_F(KeyboardHandlerTest, ExternalKeyboard) {
 
   // Simulate an external keyboard being connected. We should assume there's a
   // Caps Lock key now.
-  device_test_api_.SetKeyboardDevices(std::vector<ui::InputDevice>{
-      {1, ui::INPUT_DEVICE_EXTERNAL, "external keyboard"}});
-  device_test_api_.NotifyObserversKeyboardDeviceConfigurationChanged();
+  input_device_client_test_api_.SetKeyboardDevices(std::vector<ui::InputDevice>{
+      {2, ui::INPUT_DEVICE_EXTERNAL, "external keyboard"}});
   EXPECT_TRUE(HasCapsLock());
   EXPECT_FALSE(HasDiamondKey());
 
   // Disconnect the external keyboard and check that the key goes away.
-  device_test_api_.SetKeyboardDevices(std::vector<ui::InputDevice>());
-  device_test_api_.NotifyObserversKeyboardDeviceConfigurationChanged();
+  input_device_client_test_api_.SetKeyboardDevices({});
   EXPECT_FALSE(HasCapsLock());
   EXPECT_FALSE(HasDiamondKey());
 }
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
index 3373a7cf657..c07cfbf1074 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler.cc
@@ -9,7 +9,6 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ -120,7 +119,7 @@ void PowerHandler::OnJavascriptAllowed() {
   // Observe power management prefs used in the UI.
   base::Closure callback(base::Bind(&PowerHandler::SendPowerManagementSettings,
                                     base::Unretained(this), false /* force */));
-  pref_change_registrar_ = base::MakeUnique<PrefChangeRegistrar>();
+  pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
   pref_change_registrar_->Init(prefs_);
   pref_change_registrar_->Add(prefs::kPowerAcIdleAction, callback);
   pref_change_registrar_->Add(prefs::kPowerAcScreenDimDelayMs, callback);
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler_unittest.cc
index c5a0b4c189f..149c2b74fd1 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/device_power_handler_unittest.cc
@@ -9,7 +9,6 @@
 #include "ash/system/power/power_status.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/values.h"
@@ -40,15 +39,15 @@ class PowerHandlerTest : public testing::Test {
     std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
         chromeos::DBusThreadManager::GetSetterForTesting();
     dbus_setter->SetPowerManagerClient(
-        base::MakeUnique<chromeos::FakePowerManagerClient>());
+        std::make_unique<chromeos::FakePowerManagerClient>());
     power_manager_client_ = static_cast<chromeos::FakePowerManagerClient*>(
         chromeos::DBusThreadManager::Get()->GetPowerManagerClient());
     ash::PowerStatus::Initialize();
 
     chromeos::PowerPrefs::RegisterUserProfilePrefs(prefs_.registry());
 
-    handler_ = base::MakeUnique<TestPowerHandler>(&prefs_);
-    test_api_ = base::MakeUnique<PowerHandler::TestAPI>(handler_.get());
+    handler_ = std::make_unique<TestPowerHandler>(&prefs_);
+    test_api_ = std::make_unique<PowerHandler::TestAPI>(handler_.get());
     handler_->set_web_ui(&web_ui_);
     handler_->RegisterMessages();
     handler_->AllowJavascriptForTesting();
@@ -170,7 +169,7 @@ TEST_F(PowerHandlerTest, SendSettingsForControlledPrefs) {
   // Making an arbitrary delay pref managed should result in the idle setting
   // being reported as controlled.
   prefs_.SetManagedPref(prefs::kPowerAcScreenDimDelayMs,
-                        base::MakeUnique<base::Value>(10000));
+                        std::make_unique<base::Value>(10000));
   EXPECT_EQ(
       CreateSettingsChangedString(
           PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP,
@@ -181,7 +180,7 @@ TEST_F(PowerHandlerTest, SendSettingsForControlledPrefs) {
   // Ditto for making the lid action pref managed.
   prefs_.SetManagedPref(
       prefs::kPowerLidClosedAction,
-      base::MakeUnique<base::Value>(PowerPolicyController::ACTION_SUSPEND));
+      std::make_unique<base::Value>(PowerPolicyController::ACTION_SUSPEND));
   EXPECT_EQ(
       CreateSettingsChangedString(
           PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP,
@@ -196,9 +195,9 @@ TEST_F(PowerHandlerTest, SendIdleSettingForPrefChanges) {
   // Set a do-nothing idle action and a nonzero screen-off delay.
   prefs_.SetUserPref(
       prefs::kPowerAcIdleAction,
-      base::MakeUnique<base::Value>(PowerPolicyController::ACTION_DO_NOTHING));
+      std::make_unique<base::Value>(PowerPolicyController::ACTION_DO_NOTHING));
   prefs_.SetUserPref(prefs::kPowerAcScreenOffDelayMs,
-                     base::MakeUnique<base::Value>(10000));
+                     std::make_unique<base::Value>(10000));
   EXPECT_EQ(CreateSettingsChangedString(PowerHandler::IdleBehavior::DISPLAY_OFF,
                                         false /* idle_controlled */,
                                         PowerPolicyController::ACTION_SUSPEND,
@@ -208,7 +207,7 @@ TEST_F(PowerHandlerTest, SendIdleSettingForPrefChanges) {
 
   // Now set the delay to zero and check that the setting goes to "display on".
   prefs_.SetUserPref(prefs::kPowerAcScreenOffDelayMs,
-                     base::MakeUnique<base::Value>(0));
+                     std::make_unique<base::Value>(0));
   EXPECT_EQ(CreateSettingsChangedString(PowerHandler::IdleBehavior::DISPLAY_ON,
                                         false /* idle_controlled */,
                                         PowerPolicyController::ACTION_SUSPEND,
@@ -218,7 +217,7 @@ TEST_F(PowerHandlerTest, SendIdleSettingForPrefChanges) {
 
   // Other idle actions should result in an "other" setting.
   prefs_.SetUserPref(prefs::kPowerAcIdleAction,
-                     base::MakeUnique<base::Value>(
+                     std::make_unique<base::Value>(
                          PowerPolicyController::ACTION_STOP_SESSION));
   EXPECT_EQ(CreateSettingsChangedString(
                 PowerHandler::IdleBehavior::OTHER, false /* idle_controlled */,
@@ -231,7 +230,7 @@ TEST_F(PowerHandlerTest, SendIdleSettingForPrefChanges) {
 TEST_F(PowerHandlerTest, SendLidSettingForPrefChanges) {
   prefs_.SetUserPref(
       prefs::kPowerLidClosedAction,
-      base::MakeUnique<base::Value>(PowerPolicyController::ACTION_SHUT_DOWN));
+      std::make_unique<base::Value>(PowerPolicyController::ACTION_SHUT_DOWN));
   EXPECT_EQ(
       CreateSettingsChangedString(
           PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP,
@@ -240,7 +239,7 @@ TEST_F(PowerHandlerTest, SendLidSettingForPrefChanges) {
       GetLastSettingsChangedMessage());
 
   prefs_.SetUserPref(prefs::kPowerLidClosedAction,
-                     base::MakeUnique<base::Value>(
+                     std::make_unique<base::Value>(
                          PowerPolicyController::ACTION_STOP_SESSION));
   EXPECT_EQ(CreateSettingsChangedString(
                 PowerHandler::IdleBehavior::DISPLAY_OFF_SLEEP,
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/device_stylus_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/device_stylus_handler.cc
index 9a4e61d934d..61283919498 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/device_stylus_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/device_stylus_handler.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/ui/webui/settings/chromeos/device_stylus_handler.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -94,7 +95,7 @@ void StylusHandler::UpdateNoteTakingApps() {
     std::vector<NoteTakingAppInfo> available_apps =
         helper->GetAvailableApps(Profile::FromWebUI(web_ui()));
     for (const NoteTakingAppInfo& info : available_apps) {
-      auto dict = base::MakeUnique<base::DictionaryValue>();
+      auto dict = std::make_unique<base::DictionaryValue>();
       dict->SetString(kAppNameKey, info.name);
       dict->SetString(kAppIdKey, info.app_id);
       dict->SetBoolean(kAppPreferredKey, info.preferred);
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler_unittest.cc
index c1e69fd2215..862267270ce 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/easy_unlock_settings_handler_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/signin/easy_unlock_service.h"
 #include "chrome/browser/signin/easy_unlock_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
@@ -96,7 +95,7 @@ class TestEasyUnlockSettingsHandler : public EasyUnlockSettingsHandler {
 
 std::unique_ptr<KeyedService> CreateEasyUnlockServiceForTest(
     content::BrowserContext* context) {
-  return base::MakeUnique<FakeEasyUnlockService>(
+  return std::make_unique<FakeEasyUnlockService>(
       Profile::FromBrowserContext(context));
 }
 
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/fingerprint_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/fingerprint_handler.cc
index 71d2e404824..45d050cc78c 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/fingerprint_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/fingerprint_handler.cc
@@ -5,9 +5,9 @@
 #include "chrome/browser/ui/webui/settings/chromeos/fingerprint_handler.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ -35,14 +35,14 @@ const int kMaxAllowedFingerprints = 5;
 
 std::unique_ptr<base::DictionaryValue> GetFingerprintsInfo(
     const std::vector<std::string>& fingerprints_list) {
-  auto response = base::MakeUnique<base::DictionaryValue>();
-  auto fingerprints = base::MakeUnique<base::ListValue>();
+  auto response = std::make_unique<base::DictionaryValue>();
+  auto fingerprints = std::make_unique<base::ListValue>();
 
   DCHECK_LE(static_cast<int>(fingerprints_list.size()),
             kMaxAllowedFingerprints);
   for (auto& fingerprint_name: fingerprints_list) {
     std::unique_ptr<base::Value> str =
-        base::MakeUnique<base::Value>(fingerprint_name);
+        std::make_unique<base::Value>(fingerprint_name);
     fingerprints->Append(std::move(str));
   }
 
@@ -124,7 +124,7 @@ void FingerprintHandler::OnRestarted() {}
 void FingerprintHandler::OnEnrollScanDone(uint32_t scan_result,
                                           bool enroll_session_complete,
                                           int percent_complete) {
-  auto scan_attempt = base::MakeUnique<base::DictionaryValue>();
+  auto scan_attempt = std::make_unique<base::DictionaryValue>();
   scan_attempt->SetInteger("result", scan_result);
   scan_attempt->SetBoolean("isComplete", enroll_session_complete);
   scan_attempt->SetInteger("percentComplete", percent_complete);
@@ -144,7 +144,7 @@ void FingerprintHandler::OnAuthScanDone(
   if (it == matches.end() || it->second.size() < 1)
     return;
 
-  auto fingerprint_ids = base::MakeUnique<base::ListValue>();
+  auto fingerprint_ids = std::make_unique<base::ListValue>();
 
   for (const std::string& matched_path : it->second) {
     auto path_it = std::find(fingerprints_paths_.begin(),
@@ -154,7 +154,7 @@ void FingerprintHandler::OnAuthScanDone(
         static_cast<int>(path_it - fingerprints_paths_.begin()));
   }
 
-  auto fingerprint_attempt = base::MakeUnique<base::DictionaryValue>();
+  auto fingerprint_attempt = std::make_unique<base::DictionaryValue>();
   fingerprint_attempt->SetInteger("result", scan_result);
   fingerprint_attempt->Set("indexes", std::move(fingerprint_ids));
 
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.cc
index 38cb47f5ce6..38e54c5a8e3 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.cc
@@ -4,12 +4,14 @@
 
 #include "chrome/browser/ui/webui/settings/chromeos/internet_handler.h"
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/chromeos/tether/tether_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
@@ -35,6 +37,10 @@ const char kAddNetworkMessage[] = "addNetwork";
 const char kConfigureNetworkMessage[] = "configureNetwork";
 const char kRequestArcVpnProviders[] = "requestArcVpnProviders";
 const char kSendArcVpnProviders[] = "sendArcVpnProviders";
+const char kRequestGmsCoreNotificationsDisabledDeviceNames[] =
+    "requestGmsCoreNotificationsDisabledDeviceNames";
+const char kSendGmsCoreNotificationsDisabledDeviceNames[] =
+    "sendGmsCoreNotificationsDisabledDeviceNames";
 
 std::string ServicePathFromGuid(const std::string& guid) {
   const NetworkState* network =
@@ -66,14 +72,24 @@ namespace settings {
 
 InternetHandler::InternetHandler(Profile* profile) : profile_(profile) {
   DCHECK(profile_);
+
   arc_vpn_provider_manager_ = app_list::ArcVpnProviderManager::Get(profile_);
   if (arc_vpn_provider_manager_)
     arc_vpn_provider_manager_->AddObserver(this);
+
+  TetherService* tether_service = TetherService::Get(profile);
+  gms_core_notifications_state_tracker_ =
+      tether_service ? tether_service->GetGmsCoreNotificationsStateTracker()
+                     : nullptr;
+  if (gms_core_notifications_state_tracker_)
+    gms_core_notifications_state_tracker_->AddObserver(this);
 }
 
 InternetHandler::~InternetHandler() {
   if (arc_vpn_provider_manager_)
     arc_vpn_provider_manager_->RemoveObserver(this);
+  if (gms_core_notifications_state_tracker_)
+    gms_core_notifications_state_tracker_->RemoveObserver(this);
 }
 
 void InternetHandler::RegisterMessages() {
@@ -89,6 +105,11 @@ void InternetHandler::RegisterMessages() {
       kRequestArcVpnProviders,
       base::Bind(&InternetHandler::RequestArcVpnProviders,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kRequestGmsCoreNotificationsDisabledDeviceNames,
+      base::Bind(
+          &InternetHandler::RequestGmsCoreNotificationsDisabledDeviceNames,
+          base::Unretained(this)));
 }
 
 void InternetHandler::OnJavascriptAllowed() {}
@@ -116,6 +137,10 @@ void InternetHandler::OnArcVpnProviderUpdated(
   SendArcVpnProviders();
 }
 
+void InternetHandler::OnGmsCoreNotificationStateChanged() {
+  SetGmsCoreNotificationsDisabledDeviceNames();
+}
+
 void InternetHandler::AddNetwork(const base::ListValue* args) {
   std::string onc_type;
   if (args->GetSize() < 1 || !args->GetString(0, &onc_type)) {
@@ -205,6 +230,12 @@ void InternetHandler::RequestArcVpnProviders(const base::ListValue* args) {
   SetArcVpnProviders(arc_vpn_provider_manager_->GetArcVpnProviders());
 }
 
+void InternetHandler::RequestGmsCoreNotificationsDisabledDeviceNames(
+    const base::ListValue* args) {
+  AllowJavascript();
+  SetGmsCoreNotificationsDisabledDeviceNames();
+}
+
 void InternetHandler::SetArcVpnProviders(
     const std::vector<
         std::unique_ptr<app_list::ArcVpnProviderManager::ArcVpnProvider>>&
@@ -228,9 +259,52 @@ void InternetHandler::SendArcVpnProviders() {
   FireWebUIListener(kSendArcVpnProviders, arc_vpn_providers_value);
 }
 
+void InternetHandler::SetGmsCoreNotificationsDisabledDeviceNames() {
+  if (!gms_core_notifications_state_tracker_) {
+    // No device names should be present in the list if
+    // |gms_core_notifications_state_tracker_| is null.
+    DCHECK(device_names_without_notifications_.empty());
+    return;
+  }
+
+  device_names_without_notifications_.clear();
+
+  const std::vector<std::string> device_names =
+      gms_core_notifications_state_tracker_
+          ->GetGmsCoreNotificationsDisabledDeviceNames();
+  for (const auto& device_name : device_names) {
+    device_names_without_notifications_.emplace_back(
+        std::make_unique<base::Value>(device_name));
+  }
+  SendGmsCoreNotificationsDisabledDeviceNames();
+}
+
+void InternetHandler::SendGmsCoreNotificationsDisabledDeviceNames() {
+  if (!IsJavascriptAllowed())
+    return;
+
+  base::ListValue device_names_value;
+  for (const auto& device_name : device_names_without_notifications_)
+    device_names_value.GetList().push_back(device_name->Clone());
+
+  FireWebUIListener(kSendGmsCoreNotificationsDisabledDeviceNames,
+                    device_names_value);
+}
+
 gfx::NativeWindow InternetHandler::GetNativeWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
+void InternetHandler::SetGmsCoreNotificationsStateTrackerForTesting(
+    chromeos::tether::GmsCoreNotificationsStateTracker*
+        gms_core_notifications_state_tracker) {
+  if (gms_core_notifications_state_tracker_)
+    gms_core_notifications_state_tracker_->RemoveObserver(this);
+
+  gms_core_notifications_state_tracker_ = gms_core_notifications_state_tracker;
+  gms_core_notifications_state_tracker_->AddObserver(this);
+}
+
 }  // namespace settings
+
 }  // namespace chromeos
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.h b/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.h
index 9b845629da7..332d5dd8a5e 100644
--- a/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.h
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler.h
@@ -10,18 +10,26 @@
 #include "base/macros.h"
 #include "chrome/browser/ui/app_list/arc/arc_vpn_provider_manager.h"
 #include "chrome/browser/ui/webui/settings/settings_page_ui_handler.h"
+#include "chromeos/components/tether/gms_core_notifications_state_tracker.h"
 #include "ui/gfx/native_widget_types.h"
 
 class Profile;
 
 namespace chromeos {
+
+namespace tether {
+class GmsCoreNotificationsStateTracker;
+}  // namespace tether
+
 namespace settings {
 
 // Chrome OS Internet settings page UI handler.
 // TODO(lgcheng/stevenjb): Rename this ThirdPartyVpnHandler once configuration
 // is handled in the Settings UI (crbug.com/380937
-class InternetHandler : public app_list::ArcVpnProviderManager::Observer,
-                        public ::settings::SettingsPageUIHandler {
+class InternetHandler
+    : public app_list::ArcVpnProviderManager::Observer,
+      public chromeos::tether::GmsCoreNotificationsStateTracker::Observer,
+      public ::settings::SettingsPageUIHandler {
  public:
   explicit InternetHandler(Profile* profile);
   ~InternetHandler() override;
@@ -40,11 +48,18 @@ class InternetHandler : public app_list::ArcVpnProviderManager::Observer,
   void OnArcVpnProviderUpdated(app_list::ArcVpnProviderManager::ArcVpnProvider*
                                    arc_vpn_provider) override;
 
+  // chromeos::tether::GmsCoreNotificationsStateTracker::Observer:
+  void OnGmsCoreNotificationStateChanged() override;
+
  private:
+  friend class InternetHandlerTest;
+
   // Settings JS handlers.
   void AddNetwork(const base::ListValue* args);
   void ConfigureNetwork(const base::ListValue* args);
   void RequestArcVpnProviders(const base::ListValue* args);
+  void RequestGmsCoreNotificationsDisabledDeviceNames(
+      const base::ListValue* args);
 
   // Sets list of Arc Vpn providers.
   void SetArcVpnProviders(
@@ -55,14 +70,32 @@ class InternetHandler : public app_list::ArcVpnProviderManager::Observer,
   // Sends list of Arc Vpn providers to Chrome://settings.
   void SendArcVpnProviders();
 
+  // Sets list of names of devices whose "Google Play Services" notifications
+  // are disabled.
+  void SetGmsCoreNotificationsDisabledDeviceNames();
+
+  // Sends the list of names.
+  void SendGmsCoreNotificationsDisabledDeviceNames();
+
   gfx::NativeWindow GetNativeWindow() const;
 
+  void SetGmsCoreNotificationsStateTrackerForTesting(
+      chromeos::tether::GmsCoreNotificationsStateTracker*
+          gms_core_notifications_state_tracker);
+
   std::map<std::string, std::unique_ptr<base::DictionaryValue>>
       arc_vpn_providers_;
 
+  std::vector<std::unique_ptr<base::Value>> device_names_without_notifications_;
+
   Profile* const profile_;
 
+  // |arc_vpn_provider_manager_| and |gms_core_notifications_state_tracker_| are
+  // provided by BrowserContextKeyedServices which are guaranteed to outlive
+  // WebUIMessageHandlers.
   app_list::ArcVpnProviderManager* arc_vpn_provider_manager_;
+  chromeos::tether::GmsCoreNotificationsStateTracker*
+      gms_core_notifications_state_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(InternetHandler);
 };
diff --git a/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler_unittest.cc
new file mode 100644
index 00000000000..679b5cfdd3d
--- /dev/null
+++ b/chromium/chrome/browser/ui/webui/settings/chromeos/internet_handler_unittest.cc
@@ -0,0 +1,125 @@
+// Copyright 2017 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/ui/webui/settings/chromeos/internet_handler.h"
+
+#include <memory>
+
+#include "base/macros.h"
+#include "chrome/test/base/browser_with_test_window_test.h"
+#include "chromeos/components/tether/fake_gms_core_notifications_state_tracker.h"
+#include "content/public/test/test_web_ui.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromeos {
+
+namespace settings {
+
+namespace {
+
+const char kWebCallbackFunctionName[] = "cr.webUIListenerCallback";
+const char kSendDeviceNamesMessageType[] =
+    "sendGmsCoreNotificationsDisabledDeviceNames";
+
+class TestInternetHandler : public InternetHandler {
+ public:
+  // Pull WebUIMessageHandler::set_web_ui() into public so SetUp() can call it.
+  using InternetHandler::set_web_ui;
+
+  explicit TestInternetHandler(TestingProfile* profile)
+      : InternetHandler(profile) {}
+};
+
+}  // namespace
+
+class InternetHandlerTest : public BrowserWithTestWindowTest {
+ protected:
+  InternetHandlerTest() = default;
+
+  void SetUp() override {
+    BrowserWithTestWindowTest::SetUp();
+
+    web_ui_ = std::make_unique<content::TestWebUI>();
+
+    handler_ = std::make_unique<TestInternetHandler>(profile());
+    handler_->set_web_ui(web_ui_.get());
+    handler_->RegisterMessages();
+    handler_->AllowJavascriptForTesting();
+
+    fake_tracker_ = std::make_unique<
+        chromeos::tether::FakeGmsCoreNotificationsStateTracker>();
+    handler_->SetGmsCoreNotificationsStateTrackerForTesting(
+        fake_tracker_.get());
+  }
+
+  void TearDown() override { BrowserWithTestWindowTest::TearDown(); }
+
+  void RequestGmsCoreNotificationsDisabledDeviceNames() {
+    handler_->RequestGmsCoreNotificationsDisabledDeviceNames(nullptr);
+  }
+
+  void VerifyMostRecentDeviceNamesSent(
+      const std::vector<std::string>& expected_device_names,
+      size_t expected_num_updates) {
+    EXPECT_EQ(expected_num_updates, web_ui_->call_data().size());
+
+    const content::TestWebUI::CallData* last_call_data =
+        web_ui_->call_data()[expected_num_updates - 1].get();
+    EXPECT_TRUE(last_call_data);
+
+    // The call is structured such that the function name is the "web callback"
+    // name and the first argument is the name of the message being sent.
+    EXPECT_EQ(kWebCallbackFunctionName, last_call_data->function_name());
+    EXPECT_EQ(kSendDeviceNamesMessageType, last_call_data->arg1()->GetString());
+
+    std::vector<std::string> actual_device_names;
+    for (const auto& device_name_value : last_call_data->arg2()->GetList())
+      actual_device_names.push_back(device_name_value.GetString());
+    EXPECT_EQ(expected_device_names, actual_device_names);
+  }
+
+  std::unique_ptr<content::TestWebUI> web_ui_;
+  std::unique_ptr<chromeos::tether::FakeGmsCoreNotificationsStateTracker>
+      fake_tracker_;
+  std::unique_ptr<TestInternetHandler> handler_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InternetHandlerTest);
+};
+
+TEST_F(InternetHandlerTest, TestSendsDeviceNames) {
+  RequestGmsCoreNotificationsDisabledDeviceNames();
+  VerifyMostRecentDeviceNamesSent({} /* expected_device_names */,
+                                  1u /* expected_num_updates */);
+
+  // Set two unique names.
+  fake_tracker_->set_device_names({"device1", "device2"});
+  fake_tracker_->NotifyGmsCoreNotificationStateChanged();
+  VerifyMostRecentDeviceNamesSent(
+      {"device1", "device2"} /* expected_device_names */,
+      2u /* expected_num_updates */);
+
+  // Set three names, two of them identical. Devices with the same name should
+  // be supported, since it is possible for a user to have two phones of the
+  // same model.
+  fake_tracker_->set_device_names({"device1", "device1", "device3"});
+  fake_tracker_->NotifyGmsCoreNotificationStateChanged();
+  VerifyMostRecentDeviceNamesSent(
+      {"device1", "device1", "device3"} /* expected_device_names */,
+      3u /* expected_num_updates */);
+}
+
+TEST_F(InternetHandlerTest, TestSendsDeviceNames_StartsWithDevices) {
+  // Start with two devices before the handler requests any names.
+  fake_tracker_->set_device_names({"device1", "device2"});
+
+  RequestGmsCoreNotificationsDisabledDeviceNames();
+  VerifyMostRecentDeviceNamesSent(
+      {"device1", "device2"} /* expected_device_names */,
+      1u /* expected_num_updates */);
+}
+
+}  // namespace settings
+
+}  // namespace chromeos
diff --git a/chromium/chrome/browser/ui/webui/settings/extension_control_handler.cc b/chromium/chrome/browser/ui/webui/settings/extension_control_handler.cc
index 9eba60e7cc4..a7c9d72622c 100644
--- a/chromium/chrome/browser/ui/webui/settings/extension_control_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/extension_control_handler.cc
@@ -10,8 +10,8 @@
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/web_ui.h"
+#include "extensions/browser/disable_reason.h"
 #include "extensions/browser/extension_system.h"
-#include "extensions/common/disable_reason.h"
 
 namespace settings {
 
diff --git a/chromium/chrome/browser/ui/webui/settings/md_settings_localized_strings_provider.cc b/chromium/chrome/browser/ui/webui/settings/md_settings_localized_strings_provider.cc
index 5356c8939f8..61f926ee926 100644
--- a/chromium/chrome/browser/ui/webui/settings/md_settings_localized_strings_provider.cc
+++ b/chromium/chrome/browser/ui/webui/settings/md_settings_localized_strings_provider.cc
@@ -80,6 +80,16 @@ struct LocalizedString {
   int id;
 };
 
+#if defined(OS_CHROMEOS)
+// Generates a Google Help URL which includes a "board type" parameter. Some
+// help pages need to be adjusted depending on the type of CrOS device that is
+// accessing the page.
+base::string16 GetHelpUrlWithBoard(const std::string& original_url) {
+  return base::ASCIIToUTF16(original_url +
+                            "&b=" + base::SysInfo::GetLsbReleaseBoard());
+}
+#endif
+
 void AddLocalizedStringsBulk(content::WebUIDataSource* html_source,
                              LocalizedString localized_strings[],
                              size_t num_strings) {
@@ -135,6 +145,18 @@ void AddCommonStrings(content::WebUIDataSource* html_source, Profile* profile) {
 }
 
 void AddA11yStrings(content::WebUIDataSource* html_source) {
+#if defined(OS_CHROMEOS)
+  // The content description for select to speak is dependent on a flag
+  // until a feature launch.
+  // TODO(katie): When the feature is approved, remove this variable and
+  // callback. The feature will be always enabled.
+  int selectToSpeakDescription =
+      (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableExperimentalAccessibilityFeatures))
+          ? IDS_SETTINGS_ACCESSIBILITY_SELECT_TO_SPEAK_DESCRIPTION_FLAGS
+          : IDS_SETTINGS_ACCESSIBILITY_SELECT_TO_SPEAK_DESCRIPTION;
+#endif
+
   LocalizedString localized_strings[] = {
     {"a11yPageTitle", IDS_SETTINGS_ACCESSIBILITY},
     {"a11yWebStore", IDS_SETTINGS_ACCESSIBILITY_WEB_STORE},
@@ -173,8 +195,7 @@ void AddA11yStrings(content::WebUIDataSource* html_source) {
     {"focusHighlightLabel",
      IDS_SETTINGS_ACCESSIBILITY_FOCUS_HIGHLIGHT_DESCRIPTION},
     {"selectToSpeakTitle", IDS_SETTINGS_ACCESSIBILITY_SELECT_TO_SPEAK_TITLE},
-    {"selectToSpeakDescription",
-     IDS_SETTINGS_ACCESSIBILITY_SELECT_TO_SPEAK_DESCRIPTION},
+    {"selectToSpeakDescription", selectToSpeakDescription},
     {"selectToSpeakOptionsLabel",
      IDS_SETTINGS_ACCESSIBILITY_SELECT_TO_SPEAK_OPTIONS_LABEL},
     {"switchAccessLabel", IDS_SETTINGS_ACCESSIBILITY_SWITCH_ACCESS_DESCRIPTION},
@@ -210,8 +231,9 @@ void AddA11yStrings(content::WebUIDataSource* html_source) {
                           arraysize(localized_strings));
 
 #if defined(OS_CHROMEOS)
-  html_source->AddString("a11yLearnMoreUrl",
-                         chrome::kChromeAccessibilityHelpURL);
+  html_source->AddString(
+      "a11yLearnMoreUrl",
+      GetHelpUrlWithBoard(chrome::kChromeAccessibilityHelpURL));
 
   html_source->AddBoolean(
       "showExperimentalA11yFeatures",
@@ -335,7 +357,7 @@ void AddAndroidAppStrings(content::WebUIDataSource* html_source) {
       "androidAppsSubtext",
       l10n_util::GetStringFUTF16(
           IDS_SETTINGS_ANDROID_APPS_SUBTEXT,
-          base::ASCIIToUTF16(chrome::kAndroidAppsLearnMoreURL)));
+          GetHelpUrlWithBoard(chrome::kAndroidAppsLearnMoreURL)));
 }
 #endif
 
@@ -428,6 +450,19 @@ void AddChangePasswordStrings(content::WebUIDataSource* html_source) {
 }
 
 void AddClearBrowsingDataStrings(content::WebUIDataSource* html_source) {
+  int clear_cookies_summary_msg_id =
+      IDS_SETTINGS_CLEAR_COOKIES_AND_SITE_DATA_SUMMARY_BASIC;
+
+#if defined(OS_CHROMEOS)
+  // Mirror account reconciliation behavior is turned on for child accounts on
+  // Chrome OS.
+  if (user_manager::UserManager::Get()->GetPrimaryUser()->GetType() ==
+      user_manager::USER_TYPE_CHILD) {
+    clear_cookies_summary_msg_id =
+        IDS_SETTINGS_CLEAR_COOKIES_AND_SITE_DATA_MIRROR_SUMMARY_BASIC;
+  }
+#endif
+
   LocalizedString localized_strings[] = {
       {"clearFollowingItemsFrom", IDS_SETTINGS_CLEAR_FOLLOWING_ITEMS_FROM},
       {"clearTimeRange", IDS_SETTINGS_CLEAR_PERIOD_TITLE},
@@ -437,8 +472,7 @@ void AddClearBrowsingDataStrings(content::WebUIDataSource* html_source) {
       {"clearDownloadHistory", IDS_SETTINGS_CLEAR_DOWNLOAD_HISTORY},
       {"clearCache", IDS_SETTINGS_CLEAR_CACHE},
       {"clearCookies", IDS_SETTINGS_CLEAR_COOKIES},
-      {"clearCookiesSummary",
-       IDS_SETTINGS_CLEAR_COOKIES_AND_SITE_DATA_SUMMARY_BASIC},
+      {"clearCookiesSummary", clear_cookies_summary_msg_id},
       {"clearCookiesCounter", IDS_DEL_COOKIES_COUNTER},
       {"clearCookiesFlash", IDS_SETTINGS_CLEAR_COOKIES_FLASH},
       {"clearPasswords", IDS_SETTINGS_CLEAR_PASSWORDS},
@@ -600,6 +634,10 @@ void AddDeviceStrings(content::WebUIDataSource* html_source) {
       {"displayMirror", IDS_SETTINGS_DISPLAY_MIRROR},
       {"displayMirrorDisplayName", IDS_SETTINGS_DISPLAY_MIRROR_DISPLAY_NAME},
       {"displayNightLightLabel", IDS_SETTINGS_DISPLAY_NIGHT_LIGHT_LABEL},
+      {"displayNightLightOnAtSunset",
+       IDS_SETTINGS_DISPLAY_NIGHT_LIGHT_ON_AT_SUNSET},
+      {"displayNightLightOffAtSunrise",
+       IDS_SETTINGS_DISPLAY_NIGHT_LIGHT_OFF_AT_SUNRISE},
       {"displayNightLightScheduleCustom",
        IDS_SETTINGS_DISPLAY_NIGHT_LIGHT_SCHEDULE_CUSTOM},
       {"displayNightLightScheduleLabel",
@@ -624,6 +662,7 @@ void AddDeviceStrings(content::WebUIDataSource* html_source) {
       {"displayResolutionTextBest", IDS_SETTINGS_DISPLAY_RESOLUTION_TEXT_BEST},
       {"displayResolutionTextNative",
        IDS_SETTINGS_DISPLAY_RESOLUTION_TEXT_NATIVE},
+      {"displayZoomValue", IDS_SETTINGS_DISPLAY_ZOOM_VALUE},
       {"displayScreenTitle", IDS_SETTINGS_DISPLAY_SCREEN},
       {"displayScreenExtended", IDS_SETTINGS_DISPLAY_SCREEN_EXTENDED},
       {"displayScreenPrimary", IDS_SETTINGS_DISPLAY_SCREEN_PRIMARY},
@@ -647,14 +686,18 @@ void AddDeviceStrings(content::WebUIDataSource* html_source) {
                           base::CommandLine::ForCurrentProcess()->HasSwitch(
                               ::switches::kEnableUnifiedDesktop));
   html_source->AddBoolean("multiMirroringAvailable",
-                          base::CommandLine::ForCurrentProcess()->HasSwitch(
-                              ::switches::kEnableMultiMirroring));
+                          !base::CommandLine::ForCurrentProcess()->HasSwitch(
+                              ::switches::kDisableMultiMirroring));
 
   html_source->AddBoolean(
       "enableTouchCalibrationSetting",
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableTouchCalibrationSetting));
 
+  html_source->AddBoolean("enableDisplayZoomSetting",
+                          base::CommandLine::ForCurrentProcess()->HasSwitch(
+                              chromeos::switches::kEnableDisplayZoomSetting));
+
   html_source->AddBoolean("hasExternalTouchDevice",
                           display::HasExternalTouchscreenDevice());
 
@@ -713,7 +756,7 @@ void AddDeviceStrings(content::WebUIDataSource* html_source) {
   AddLocalizedStringsBulk(html_source, power_strings, arraysize(power_strings));
 
   html_source->AddString("naturalScrollLearnMoreLink",
-                         base::ASCIIToUTF16(chrome::kNaturalScrollHelpURL));
+                         GetHelpUrlWithBoard(chrome::kNaturalScrollHelpURL));
 }
 #endif
 
@@ -759,14 +802,13 @@ void AddChromeCleanupStrings(content::WebUIDataSource* html_source) {
        IDS_SETTINGS_RESET_CLEANUP_EXPLANATION_SCAN_ERROR},
       {"chromeCleanupFindButtonLable",
        IDS_SETTINGS_RESET_CLEANUP_FIND_BUTTON_LABEL},
-      {"chromeCleanupLinkShowFiles",
+      {"chromeCleanupLinkShowItems",
        IDS_SETTINGS_RESET_CLEANUP_LINK_SHOW_FILES},
       {"chromeCleanupLogsUploadPermission", IDS_CHROME_CLEANUP_LOGS_PERMISSION},
       {"chromeCleanupRemoveButtonLabel",
        IDS_SETTINGS_RESET_CLEANUP_REMOVE_BUTTON_LABEL},
       {"chromeCleanupRestartButtonLabel",
        IDS_SETTINGS_RESET_CLEANUP_RESTART_BUTTON_LABEL},
-      {"chromeCleanupTitleDone", IDS_SETTINGS_RESET_CLEANUP_TITLE_DONE},
       {"chromeCleanupTitleErrorCantRemove",
        IDS_SETTINGS_RESET_CLEANUP_TITLE_ERROR_CANT_REMOVE},
       {"chromeCleanupTitleErrorPermissions",
@@ -778,7 +820,10 @@ void AddChromeCleanupStrings(content::WebUIDataSource* html_source) {
       {"chromeCleanupTitleNothingFound",
        IDS_SETTINGS_RESET_CLEANUP_TITLE_NOTHING_FOUND},
       {"chromeCleanupTitleRemove", IDS_SETTINGS_RESET_CLEANUP_TITLE_REMOVE},
-      {"chromeCleanupTitleRemoved", IDS_SETTINGS_RESET_CLEANUP_TITLE_REMOVED},
+      {"chromeCleanupTitleRemoved",
+       safe_browsing::UserInitiatedCleanupsEnabled()
+           ? IDS_SETTINGS_RESET_CLEANUP_TITLE_DONE
+           : IDS_SETTINGS_RESET_CLEANUP_TITLE_REMOVED},
       {"chromeCleanupTitleRemoving", IDS_SETTINGS_RESET_CLEANUP_TITLE_REMOVING},
       {"chromeCleanupTitleRestart", IDS_SETTINGS_RESET_CLEANUP_TITLE_RESTART},
       {"chromeCleanupTitleScanning", IDS_SETTINGS_RESET_CLEANUP_TITLE_SCANNING},
@@ -788,6 +833,10 @@ void AddChromeCleanupStrings(content::WebUIDataSource* html_source) {
        IDS_SETTINGS_RESET_CLEANUP_TRY_AGAIN_BUTTON_LABEL},
       {"chromeCleanupTitleLogsPermissionExplanation",
        IDS_SETTINGS_RESET_CLEANUP_LOGS_PERMISSION_EXPLANATION},
+      {"chromeCleanupTitleCleanupUnavailable",
+       IDS_SETTINGS_RESET_CLEANUP_TITLE_CLEANUP_UNAVAILABLE},
+      {"chromeCleanupExplanationCleanupUnavailable",
+       IDS_SETTINGS_RESET_CLEANUP_EXPLANATION_CLEANUP_UNAVAILABLE},
   };
 
   AddLocalizedStringsBulk(html_source, localized_strings,
@@ -814,8 +863,16 @@ void AddChromeCleanupStrings(content::WebUIDataSource* html_source) {
 
 void AddResetStrings(content::WebUIDataSource* html_source) {
   LocalizedString localized_strings[] = {
+#if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
+    {"resetPageTitle", safe_browsing::UserInitiatedCleanupsEnabled()
+                           ? IDS_SETTINGS_RESET_AND_CLEANUP
+                           : IDS_SETTINGS_RESET},
+#else
     {"resetPageTitle", IDS_SETTINGS_RESET},
-    {"resetPageDescription", IDS_SETTINGS_RESET_PROFILE_SETTINGS_DESCRIPTION},
+#endif
+    {"resetTrigger", IDS_SETTINGS_RESET},
+    {"resetTriggerDescription",
+     IDS_SETTINGS_RESET_PROFILE_SETTINGS_DESCRIPTION},
     {"resetPageExplanation", IDS_RESET_PROFILE_SETTINGS_EXPLANATION},
     {"triggeredResetPageExplanation",
      IDS_TRIGGERED_RESET_PROFILE_SETTINGS_EXPLANATION},
@@ -834,8 +891,6 @@ void AddResetStrings(content::WebUIDataSource* html_source) {
     {"resetProfileBannerButton", IDS_SETTINGS_RESET_BANNER_RESET_BUTTON_TEXT},
     {"resetProfileBannerDescription", IDS_SETTINGS_RESET_BANNER_TEXT},
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
-    // The page title to be used if user initiated cleanups are enabled.
-    {"resetAndCleanupPageTitle", IDS_SETTINGS_RESET_AND_CLEANUP},
     {"resetCleanupComputerTrigger",
      IDS_SETTINGS_RESET_CLEAN_UP_COMPUTER_TRIGGER},
     {"resetCleanupComputerTriggerDescription",
@@ -883,26 +938,24 @@ void AddImportDataStrings(content::WebUIDataSource* html_source) {
 void AddDateTimeStrings(content::WebUIDataSource* html_source) {
   LocalizedString localized_strings[] = {
       {"dateTimePageTitle", IDS_SETTINGS_DATE_TIME},
-      {"timeZoneColon", IDS_SETTINGS_TIME_ZONE},
+      {"timeZone", IDS_SETTINGS_TIME_ZONE},
+      {"selectTimeZoneResolveMethod",
+       IDS_SETTINGS_SELECT_TIME_ZONE_RESOLVE_METHOD},
       {"timeZoneGeolocation", IDS_SETTINGS_TIME_ZONE_GEOLOCATION},
       {"timeZoneButton", IDS_SETTINGS_TIME_ZONE_BUTTON},
       {"timeZoneSubpageTitle", IDS_SETTINGS_TIME_ZONE_SUBPAGE_TITLE},
       {"setTimeZoneAutomaticallyDisabled",
        IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_DISABLED},
+      {"setTimeZoneAutomaticallyOn",
+       IDS_SETTINGS_TIME_ZONE_DETECTION_SET_AUTOMATICALLY},
+      {"setTimeZoneAutomaticallyOff",
+       IDS_SETTINGS_TIME_ZONE_DETECTION_CHOOSE_FROM_LIST},
       {"setTimeZoneAutomaticallyIpOnlyDefault",
        IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_IP_ONLY_DEFAULT},
-      {"setTimeZoneAutomaticallyIpOnlyDefaultDescription",
-       IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_IP_ONLY_DESCRIPTION},
       {"setTimeZoneAutomaticallyWithWiFiAccessPointsData",
        IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_SEND_WIFI_AP},
-      {"setTimeZoneAutomaticallyWithWiFiAccessPointsDataDescription",
-       IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_SEND_WIFI_AP_DESCRIPTION},
       {"setTimeZoneAutomaticallyWithAllLocationInfo",
        IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_SEND_ALL_INFO},
-      {"setTimeZoneAutomaticallyWithAllLocationInfoDescription",
-       IDS_SETTINGS_TIME_ZONE_DETECTION_MODE_SEND_ALL_INFO_DESCRIPTION},
-      {"selectYourTimeZone",
-       IDS_SETTINGS_TIME_ZONE_DETECTION_SELECT_YOUR_TIME_ZONE},
       {"use24HourClock", IDS_SETTINGS_USE_24_HOUR_CLOCK},
       {"setDateTime", IDS_SETTINGS_SET_DATE_TIME},
   };
@@ -965,7 +1018,7 @@ void AddEasyUnlockStrings(content::WebUIDataSource* html_source) {
           IDS_SETTINGS_EASY_UNLOCK_PROXIMITY_THRESHOLD_LABEL, device_name));
 
   html_source->AddString("easyUnlockLearnMoreURL",
-                         chrome::kEasyUnlockLearnMoreUrl);
+                         GetHelpUrlWithBoard(chrome::kEasyUnlockLearnMoreUrl));
 }
 
 void AddInternetStrings(content::WebUIDataSource* html_source) {
@@ -1038,6 +1091,23 @@ void AddInternetStrings(content::WebUIDataSource* html_source) {
        IDS_SETTINGS_INTERNET_NETWORK_SECTION_PROXY_ACCESSIBILITY_LABEL},
       {"networkShared", IDS_SETTINGS_INTERNET_NETWORK_SHARED},
       {"networkVpnBuiltin", IDS_NETWORK_TYPE_VPN_BUILTIN},
+      {"networkOutOfRange", IDS_SETTINGS_INTERNET_WIFI_NETWORK_OUT_OF_RANGE},
+      {"tetherPhoneOutOfRange",
+       IDS_SETTINGS_INTERNET_TETHER_PHONE_OUT_OF_RANGE},
+      {"gmscoreNotificationsTitle",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_TITLE},
+      {"gmscoreNotificationsOneDeviceSubtitle",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_ONE_DEVICE_SUBTITLE},
+      {"gmscoreNotificationsTwoDevicesSubtitle",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_TWO_DEVICES_SUBTITLE},
+      {"gmscoreNotificationsManyDevicesSubtitle",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_MANY_DEVICES_SUBTITLE},
+      {"gmscoreNotificationsFirstStep",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_FIRST_STEP},
+      {"gmscoreNotificationsSecondStep",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_SECOND_STEP},
+      {"gmscoreNotificationsThirdStep",
+       IDS_SETTINGS_INTERNET_GMSCORE_NOTIFICATIONS_THIRD_STEP},
       {"tetherConnectionDialogTitle",
        IDS_SETTINGS_INTERNET_TETHER_CONNECTION_DIALOG_TITLE},
       {"tetherConnectionAvailableDeviceTitle",
@@ -1066,17 +1136,14 @@ void AddInternetStrings(content::WebUIDataSource* html_source) {
                           arraysize(localized_strings));
 
   html_source->AddBoolean("networkSettingsConfig",
-                          base::CommandLine::ForCurrentProcess()->HasSwitch(
-                              chromeos::switches::kNetworkSettingsConfig));
+                          chromeos::switches::IsNetworkSettingsConfigEnabled());
   html_source->AddString("networkGoogleNameserversLearnMoreUrl",
                          chrome::kGoogleNameserversLearnMoreURL);
-
-  std::string tether_learn_more_url(chrome::kInstantTetheringLearnMoreURL);
-  tether_learn_more_url += "&b=" + base::SysInfo::GetLsbReleaseBoard();
   html_source->AddString(
       "internetNoNetworksMobileData",
-      l10n_util::GetStringFUTF16(IDS_SETTINGS_INTERNET_NO_NETWORKS_MOBILE_DATA,
-                                 base::ASCIIToUTF16(tether_learn_more_url)));
+      l10n_util::GetStringFUTF16(
+          IDS_SETTINGS_INTERNET_NO_NETWORKS_MOBILE_DATA,
+          GetHelpUrlWithBoard(chrome::kInstantTetheringLearnMoreURL)));
 }
 #endif
 
@@ -1130,9 +1197,14 @@ void AddLanguagesStrings(content::WebUIDataSource* html_source) {
     {"addDictionaryWordLabel", IDS_SETTINGS_LANGUAGES_ADD_DICTIONARY_WORD},
     {"addDictionaryWordButton",
      IDS_SETTINGS_LANGUAGES_ADD_DICTIONARY_WORD_BUTTON},
+    {"addDictionaryWordDuplicateError",
+     IDS_SETTINGS_LANGUAGES_ADD_DICTIONARY_WORD_DUPLICATE_ERROR},
+    {"addDictionaryWordLengthError",
+     IDS_SETTINGS_LANGUAGES_ADD_DICTIONARY_WORD_LENGTH_ERROR},
     {"customDictionaryWords", IDS_SETTINGS_LANGUAGES_DICTIONARY_WORDS},
     {"noCustomDictionaryWordsFound",
      IDS_SETTINGS_LANGUAGES_DICTIONARY_WORDS_NONE},
+    {"spellCheckDisabled", IDS_SETTINGS_LANGUAGES_SPELL_CHECK_DISABLED},
 #endif
   };
   AddLocalizedStringsBulk(html_source, localized_strings,
@@ -1186,6 +1258,8 @@ void AddOnStartupStrings(content::WebUIDataSource* html_source) {
       {"onStartupEditPage", IDS_SETTINGS_ON_STARTUP_EDIT_PAGE},
       {"onStartupSiteUrl", IDS_SETTINGS_ON_STARTUP_SITE_URL},
       {"onStartupRemove", IDS_SETTINGS_ON_STARTUP_REMOVE},
+      {"onStartupInvalidUrl", IDS_SETTINGS_INVALID_URL},
+      {"onStartupUrlTooLong", IDS_SETTINGS_URL_TOOL_LONG},
   };
   AddLocalizedStringsBulk(html_source, localized_strings,
                           arraysize(localized_strings));
@@ -1294,8 +1368,6 @@ void AddPeopleStrings(content::WebUIDataSource* html_source) {
      IDS_SETTINGS_ADD_FINGERPRINT_DIALOG_FINGER_TOO_FAST},
     {"configureFingerprintImmobile",
      IDS_SETTINGS_ADD_FINGERPRINT_DIALOG_FINGER_IMMOBILE},
-    {"configureFingerprintCancelButton",
-     IDS_SETTINGS_ADD_FINGERPRINT_DIALOG_CANCEL_BUTTON},
     {"configureFingerprintDoneButton",
      IDS_SETTINGS_ADD_FINGERPRINT_DIALOG_DONE_BUTTON},
     {"configureFingerprintAddAnotherButton",
@@ -1438,7 +1510,12 @@ void AddPeopleStrings(content::WebUIDataSource* html_source) {
   }
 
   html_source->AddString("syncLearnMoreUrl", chrome::kSyncLearnMoreURL);
-  html_source->AddString("autofillHelpURL", autofill::kHelpURL);
+  html_source->AddString("autofillHelpURL",
+#if defined(OS_CHROMEOS)
+                         GetHelpUrlWithBoard(autofill::kHelpURL));
+#else
+                         autofill::kHelpURL);
+#endif
   html_source->AddString("supervisedUsersUrl",
                          chrome::kLegacySupervisedUserManagementURL);
 
@@ -1446,7 +1523,11 @@ void AddPeopleStrings(content::WebUIDataSource* html_source) {
       "encryptWithSyncPassphraseLabel",
       l10n_util::GetStringFUTF8(
           IDS_SETTINGS_ENCRYPT_WITH_SYNC_PASSPHRASE_LABEL,
+#if defined(OS_CHROMEOS)
+          GetHelpUrlWithBoard(chrome::kSyncEncryptionHelpURL)));
+#else
           base::ASCIIToUTF16(chrome::kSyncEncryptionHelpURL)));
+#endif
 
   std::string sync_dashboard_url =
       google_util::AppendGoogleLocaleParam(
@@ -1487,6 +1568,10 @@ void AddPeopleStrings(content::WebUIDataSource* html_source) {
 
   html_source->AddBoolean("profileShortcutsEnabled",
                           ProfileShortcutManager::IsFeatureEnabled());
+
+  html_source->AddBoolean(
+      "changePictureVideoModeEnabled",
+      base::FeatureList::IsEnabled(features::kChangePictureVideoMode));
 }
 
 void AddPrintingStrings(content::WebUIDataSource* html_source) {
@@ -1516,7 +1601,6 @@ void AddPrintingStrings(content::WebUIDataSource* html_source) {
      IDS_SETTINGS_PRINTING_CUPS_ADD_PRINTERS_MANUALLY_TITLE},
     {"selectManufacturerAndModelTitle",
      IDS_SETTINGS_PRINTING_CUPS_SELECT_MANUFACTURER_AND_MODEL_TITLE},
-    {"cancelButtonText", IDS_SETTINGS_PRINTING_CUPS_ADD_PRINTER_BUTTON_CANCEL},
     {"addPrinterButtonText", IDS_SETTINGS_PRINTING_CUPS_ADD_PRINTER_BUTTON_ADD},
     {"printerDetailsAdvanced", IDS_SETTINGS_PRINTING_CUPS_PRINTER_ADVANCED},
     {"printerDetailsA11yLabel",
@@ -1583,7 +1667,7 @@ void AddPrintingStrings(content::WebUIDataSource* html_source) {
 
 #if defined(OS_CHROMEOS)
   html_source->AddString("printingCUPSPrintLearnMoreUrl",
-                         chrome::kCupsPrintLearnMoreURL);
+                         GetHelpUrlWithBoard(chrome::kCupsPrintLearnMoreURL));
 #endif
 }
 
@@ -1636,15 +1720,24 @@ void AddPrivacyStrings(content::WebUIDataSource* html_source,
           *profile->GetPrefs(),
           IDS_SETTINGS_SAFEBROWSING_ENABLE_EXTENDED_REPORTING,
           IDS_SETTINGS_SAFEBROWSING_ENABLE_SCOUT_REPORTING));
-  html_source->AddString("improveBrowsingExperience",
-                         l10n_util::GetStringFUTF16(
-                             IDS_SETTINGS_IMPROVE_BROWSING_EXPERIENCE,
-                             base::ASCIIToUTF16(chrome::kPrivacyLearnMoreURL)));
+  html_source->AddString(
+      "improveBrowsingExperience",
+      l10n_util::GetStringFUTF16(
+          IDS_SETTINGS_IMPROVE_BROWSING_EXPERIENCE,
+#if defined(OS_CHROMEOS)
+          GetHelpUrlWithBoard(chrome::kPrivacyLearnMoreURL)));
+#else
+          base::ASCIIToUTF16(chrome::kPrivacyLearnMoreURL)));
+#endif
   html_source->AddString(
       "doNotTrackDialogMessage",
       l10n_util::GetStringFUTF16(
           IDS_SETTINGS_ENABLE_DO_NOT_TRACK_DIALOG_TEXT,
+#if defined(OS_CHROMEOS)
+          GetHelpUrlWithBoard(chrome::kDoNotTrackLearnMoreURL)));
+#else
           base::ASCIIToUTF16(chrome::kDoNotTrackLearnMoreURL)));
+#endif
   html_source->AddString(
       "exceptionsLearnMoreURL",
       base::ASCIIToUTF16(chrome::kContentSettingsExceptionsLearnMoreURL));
diff --git a/chromium/chrome/browser/ui/webui/settings/md_settings_ui.cc b/chromium/chrome/browser/ui/webui/settings/md_settings_ui.cc
index 6c230353db7..30779acd938 100644
--- a/chromium/chrome/browser/ui/webui/settings/md_settings_ui.cc
+++ b/chromium/chrome/browser/ui/webui/settings/md_settings_ui.cc
@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ -46,6 +47,7 @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
+#include "printing/features/features.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win.h"
@@ -62,7 +64,6 @@
 
 #if defined(OS_CHROMEOS)
 #include "ash/public/cpp/stylus_utils.h"
-#include "ash/system/power/power_status.h"
 #include "chrome/browser/chromeos/arc/arc_util.h"
 #include "chrome/browser/chromeos/login/quick_unlock/quick_unlock_utils.h"
 #include "chrome/browser/ui/ash/ash_util.h"
@@ -84,7 +85,6 @@
 #include "chromeos/chromeos_switches.h"
 #include "components/arc/arc_util.h"
 #else  // !defined(OS_CHROMEOS)
-#include "chrome/browser/ui/webui/settings/printing_handler.h"
 #include "chrome/browser/ui/webui/settings/settings_default_browser_handler.h"
 #include "chrome/browser/ui/webui/settings/settings_manage_profile_handler.h"
 #include "chrome/browser/ui/webui/settings/system_handler.h"
@@ -96,6 +96,10 @@
 #include "chrome/browser/ui/webui/settings/native_certificates_handler.h"
 #endif  // defined(USE_NSS_CERTS)
 
+#if BUILDFLAG(ENABLE_PRINTING) && !defined(OS_CHROMEOS)
+#include "chrome/browser/ui/webui/settings/printing_handler.h"
+#endif
+
 #if defined(SAFE_BROWSING_DB_LOCAL)
 #include "chrome/browser/safe_browsing/chrome_password_protection_service.h"
 #include "chrome/browser/ui/webui/settings/change_password_handler.h"
@@ -121,72 +125,75 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
 #endif
 
   Profile* profile = Profile::FromWebUI(web_ui);
-  AddSettingsPageUIHandler(base::MakeUnique<AppearanceHandler>(web_ui));
+  AddSettingsPageUIHandler(std::make_unique<AppearanceHandler>(web_ui));
 
 #if defined(USE_NSS_CERTS)
   AddSettingsPageUIHandler(
-      base::MakeUnique<certificate_manager::CertificatesHandler>());
+      std::make_unique<certificate_manager::CertificatesHandler>());
 #elif defined(OS_WIN) || defined(OS_MACOSX)
-  AddSettingsPageUIHandler(base::MakeUnique<NativeCertificatesHandler>());
+  AddSettingsPageUIHandler(std::make_unique<NativeCertificatesHandler>());
 #endif  // defined(USE_NSS_CERTS)
 
-  AddSettingsPageUIHandler(base::MakeUnique<BrowserLifetimeHandler>());
-  AddSettingsPageUIHandler(base::MakeUnique<ClearBrowsingDataHandler>(web_ui));
-  AddSettingsPageUIHandler(base::MakeUnique<CookiesViewHandler>());
-  AddSettingsPageUIHandler(base::MakeUnique<DownloadsHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<ExtensionControlHandler>());
-  AddSettingsPageUIHandler(base::MakeUnique<FontHandler>(web_ui));
-  AddSettingsPageUIHandler(base::MakeUnique<ImportDataHandler>());
+  AddSettingsPageUIHandler(std::make_unique<BrowserLifetimeHandler>());
+  AddSettingsPageUIHandler(std::make_unique<ClearBrowsingDataHandler>(web_ui));
+  AddSettingsPageUIHandler(std::make_unique<CookiesViewHandler>());
+  AddSettingsPageUIHandler(std::make_unique<DownloadsHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<ExtensionControlHandler>());
+  AddSettingsPageUIHandler(std::make_unique<FontHandler>(web_ui));
+  AddSettingsPageUIHandler(std::make_unique<ImportDataHandler>());
 
 #if defined(OS_WIN) || defined(OS_CHROMEOS)
-  AddSettingsPageUIHandler(base::MakeUnique<LanguagesHandler>(web_ui));
+  AddSettingsPageUIHandler(std::make_unique<LanguagesHandler>(web_ui));
 #endif  // defined(OS_WIN) || defined(OS_CHROMEOS)
 
   AddSettingsPageUIHandler(
-      base::MakeUnique<MediaDevicesSelectionHandler>(profile));
+      std::make_unique<MediaDevicesSelectionHandler>(profile));
 #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_CHROMEOS)
-  AddSettingsPageUIHandler(base::MakeUnique<MetricsReportingHandler>());
+  AddSettingsPageUIHandler(std::make_unique<MetricsReportingHandler>());
 #endif
-  AddSettingsPageUIHandler(base::MakeUnique<OnStartupHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<PeopleHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<ProfileInfoHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<ProtocolHandlersHandler>());
+  AddSettingsPageUIHandler(std::make_unique<OnStartupHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<PeopleHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<ProfileInfoHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<ProtocolHandlersHandler>());
   AddSettingsPageUIHandler(
-      base::MakeUnique<SafeBrowsingHandler>(profile->GetPrefs()));
-  AddSettingsPageUIHandler(base::MakeUnique<SearchEnginesHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<SiteSettingsHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<StartupPagesHandler>(web_ui));
+      std::make_unique<SafeBrowsingHandler>(profile->GetPrefs()));
+  AddSettingsPageUIHandler(std::make_unique<SearchEnginesHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<SiteSettingsHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<StartupPagesHandler>(web_ui));
 
 #if defined(OS_CHROMEOS)
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::AccessibilityHandler>(web_ui));
+      std::make_unique<chromeos::settings::AccessibilityHandler>(web_ui));
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::AndroidAppsHandler>(profile));
+      std::make_unique<chromeos::settings::AndroidAppsHandler>(profile));
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::ChangePictureHandler>());
+      std::make_unique<chromeos::settings::ChangePictureHandler>());
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::CupsPrintersHandler>(web_ui));
+      std::make_unique<chromeos::settings::CupsPrintersHandler>(web_ui));
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::FingerprintHandler>(profile));
+      std::make_unique<chromeos::settings::FingerprintHandler>(profile));
   if (chromeos::switches::IsVoiceInteractionEnabled()) {
     AddSettingsPageUIHandler(
-        base::MakeUnique<chromeos::settings::GoogleAssistantHandler>(profile));
+        std::make_unique<chromeos::settings::GoogleAssistantHandler>(profile));
   }
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::KeyboardHandler>());
+      std::make_unique<chromeos::settings::KeyboardHandler>());
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::PointerHandler>());
+      std::make_unique<chromeos::settings::PointerHandler>());
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::StorageHandler>());
+      std::make_unique<chromeos::settings::StorageHandler>());
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::StylusHandler>());
+      std::make_unique<chromeos::settings::StylusHandler>());
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::InternetHandler>(profile));
+      std::make_unique<chromeos::settings::InternetHandler>(profile));
 #else
-  AddSettingsPageUIHandler(base::MakeUnique<DefaultBrowserHandler>(web_ui));
-  AddSettingsPageUIHandler(base::MakeUnique<ManageProfileHandler>(profile));
-  AddSettingsPageUIHandler(base::MakeUnique<SystemHandler>());
-  AddSettingsPageUIHandler(base::MakeUnique<PrintingHandler>());
+  AddSettingsPageUIHandler(std::make_unique<DefaultBrowserHandler>(web_ui));
+  AddSettingsPageUIHandler(std::make_unique<ManageProfileHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<SystemHandler>());
+#endif
+
+#if BUILDFLAG(ENABLE_PRINTING) && !defined(OS_CHROMEOS)
+  AddSettingsPageUIHandler(std::make_unique<PrintingHandler>());
 #endif
 
   content::WebUIDataSource* html_source =
@@ -196,7 +203,7 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
   bool chromeCleanupEnabled = false;
   bool userInitiatedCleanupsEnabled = false;
 
-  AddSettingsPageUIHandler(base::MakeUnique<ChromeCleanupHandler>(profile));
+  AddSettingsPageUIHandler(std::make_unique<ChromeCleanupHandler>(profile));
 
   safe_browsing::ChromeCleanerController* cleaner_controller =
       safe_browsing::ChromeCleanerController::GetInstance();
@@ -204,9 +211,6 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
   userInitiatedCleanupsEnabled = safe_browsing::UserInitiatedCleanupsEnabled();
 
 #if defined(GOOGLE_CHROME_BUILD)
-  if (cleaner_controller->IsPoweredByPartner())
-    html_source->AddBoolean("cleanupPoweredByPartner", true);
-
   html_source->AddResourcePath("partner-logo.svg", IDR_CHROME_CLEANUP_PARTNER);
 #if BUILDFLAG(OPTIMIZE_WEBUI)
   exclude_from_gzip.push_back("partner-logo.svg");
@@ -221,15 +225,19 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
 
 #endif  // defined(OS_WIN)
 
+  bool password_protection_available = false;
 #if defined(SAFE_BROWSING_DB_LOCAL)
   safe_browsing::ChromePasswordProtectionService* password_protection =
       safe_browsing::ChromePasswordProtectionService::
           GetPasswordProtectionService(profile);
+  password_protection_available = !!password_protection;
   if (password_protection) {
     AddSettingsPageUIHandler(
-        base::MakeUnique<ChangePasswordHandler>(profile, password_protection));
+        std::make_unique<ChangePasswordHandler>(profile, password_protection));
   }
 #endif
+  html_source->AddBoolean("passwordProtectionAvailable",
+                          password_protection_available);
 
 #if defined(OS_CHROMEOS)
   chromeos::settings::EasyUnlockSettingsHandler* easy_unlock_handler =
@@ -242,7 +250,7 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
       chromeos::settings::DateTimeHandler::Create(html_source)));
 
   AddSettingsPageUIHandler(
-      base::MakeUnique<chromeos::settings::StylusHandler>());
+      std::make_unique<chromeos::settings::StylusHandler>());
   html_source->AddBoolean(
       "quickUnlockEnabled",
       chromeos::quick_unlock::IsPinEnabled(profile->GetPrefs()));
@@ -270,7 +278,7 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
   bool enable_power_settings = !ash_util::IsRunningInMash();
   html_source->AddBoolean("enablePowerSettings", enable_power_settings);
   if (enable_power_settings) {
-    AddSettingsPageUIHandler(base::MakeUnique<chromeos::settings::PowerHandler>(
+    AddSettingsPageUIHandler(std::make_unique<chromeos::settings::PowerHandler>(
         profile->GetPrefs()));
   }
 #endif
@@ -289,7 +297,7 @@ MdSettingsUI::MdSettingsUI(content::WebUI* web_ui)
       base::WrapUnique(ResetSettingsHandler::Create(html_source, profile)));
 
   // Add the metrics handler to write uma stats.
-  web_ui->AddMessageHandler(base::MakeUnique<MetricsHandler>());
+  web_ui->AddMessageHandler(std::make_unique<MetricsHandler>());
 
 #if BUILDFLAG(OPTIMIZE_WEBUI)
   html_source->AddResourcePath("crisper.js", IDR_MD_SETTINGS_CRISPER_JS);
@@ -351,14 +359,12 @@ void MdSettingsUI::DocumentOnLoadCompletedInMainFrame() {
 }
 
 #if defined(OS_WIN)
-void MdSettingsUI::UpdateCleanupDataSource(bool cleanupEnabled,
-                                           bool partnerPowered) {
+void MdSettingsUI::UpdateCleanupDataSource(bool cleanupEnabled) {
   DCHECK(web_ui());
   Profile* profile = Profile::FromWebUI(web_ui());
 
   std::unique_ptr<base::DictionaryValue> update(new base::DictionaryValue);
   update->SetBoolean("chromeCleanupEnabled", cleanupEnabled);
-  update->SetBoolean("cleanupPoweredByPartner", partnerPowered);
 
   content::WebUIDataSource::Update(profile, chrome::kChromeUISettingsHost,
                                    std::move(update));
diff --git a/chromium/chrome/browser/ui/webui/settings/md_settings_ui.h b/chromium/chrome/browser/ui/webui/settings/md_settings_ui.h
index 2d3fd4e95ee..034c00defaf 100644
--- a/chromium/chrome/browser/ui/webui/settings/md_settings_ui.h
+++ b/chromium/chrome/browser/ui/webui/settings/md_settings_ui.h
@@ -50,7 +50,7 @@ class MdSettingsUI : public content::WebUIController,
   base::Time load_start_time_;
 
 #if defined(OS_WIN)
-  void UpdateCleanupDataSource(bool cleanupEnabled, bool partnerPowered);
+  void UpdateCleanupDataSource(bool cleanupEnabled);
   std::unique_ptr<safe_browsing::ChromeCleanerStateChangeObserver>
       cleanup_observer_;
 #endif
diff --git a/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler.cc b/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler.cc
index 77b1b4e6b22..60d70778592 100644
--- a/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler.cc
@@ -8,7 +8,6 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
@@ -33,13 +32,13 @@ void MetricsReportingHandler::RegisterMessages() {
 }
 
 void MetricsReportingHandler::OnJavascriptAllowed() {
-  pref_member_ = base::MakeUnique<BooleanPrefMember>();
+  pref_member_ = std::make_unique<BooleanPrefMember>();
   pref_member_->Init(metrics::prefs::kMetricsReportingEnabled,
                      g_browser_process->local_state(),
                      base::Bind(&MetricsReportingHandler::OnPrefChanged,
                                 base::Unretained(this)));
 
-  policy_registrar_ = base::MakeUnique<policy::PolicyChangeRegistrar>(
+  policy_registrar_ = std::make_unique<policy::PolicyChangeRegistrar>(
       g_browser_process->policy_service(),
       policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME, std::string()));
   policy_registrar_->Observe(policy::key::kMetricsReportingEnabled,
@@ -63,7 +62,7 @@ void MetricsReportingHandler::HandleGetMetricsReporting(
 std::unique_ptr<base::DictionaryValue>
     MetricsReportingHandler::CreateMetricsReportingDict() {
   std::unique_ptr<base::DictionaryValue> dict(
-      base::MakeUnique<base::DictionaryValue>());
+      std::make_unique<base::DictionaryValue>());
   dict->SetBoolean("enabled",
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled());
   dict->SetBoolean("managed", IsMetricsReportingPolicyManaged());
diff --git a/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler_unittest.cc
index 2452adb6c79..d5adb2866a2 100644
--- a/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/metrics_reporting_handler_unittest.cc
@@ -6,7 +6,6 @@
 
 #include "chrome/browser/ui/webui/settings/metrics_reporting_handler.h"
 
-#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
@@ -51,7 +50,7 @@ class MetricsReportingHandlerTest : public testing::Test {
     EXPECT_TRUE(test_web_ui()->call_data().empty());
 
     base::ListValue args;
-    args.Append(base::MakeUnique<base::Value>(1));
+    args.Append(std::make_unique<base::Value>(1));
     handler()->HandleGetMetricsReporting(&args);
 
     EXPECT_TRUE(handler()->IsJavascriptAllowed());
@@ -106,7 +105,7 @@ TEST_F(MetricsReportingHandlerTest, PolicyChangesNotifyPage) {
   // Change the policy, check that the page was notified.
   map()->Set(policy::key::kMetricsReportingEnabled,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
-             policy::POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true),
+             policy::POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(true),
              nullptr);
   provider()->UpdateChromePolicy(*map());
   EXPECT_EQ(1u, test_web_ui()->call_data().size());
@@ -117,7 +116,7 @@ TEST_F(MetricsReportingHandlerTest, PolicyChangesNotifyPage) {
   // Policies changing while JavaScript is disabled shouldn't notify the page.
   map()->Set(policy::key::kMetricsReportingEnabled,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
-             policy::POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false),
+             policy::POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(false),
              nullptr);
   provider()->UpdateChromePolicy(*map());
   EXPECT_TRUE(test_web_ui()->call_data().empty());
diff --git a/chromium/chrome/browser/ui/webui/settings/people_handler.cc b/chromium/chrome/browser/ui/webui/settings/people_handler.cc
index 0126d1c8b56..170db11ae9c 100644
--- a/chromium/chrome/browser/ui/webui/settings/people_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/people_handler.cc
@@ -314,7 +314,7 @@ void PeopleHandler::DisplayGaiaLoginInNewTabOrWindow(
   }
 
   if (url.is_valid())
-    chrome::ShowSingletonTab(browser, url);
+    ShowSingletonTab(browser, url);
 }
 #endif
 
diff --git a/chromium/chrome/browser/ui/webui/settings/people_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/people_handler_unittest.cc
index 5b314f5a314..ec5442d0d1b 100644
--- a/chromium/chrome/browser/ui/webui/settings/people_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/people_handler_unittest.cc
@@ -497,7 +497,7 @@ TEST_F(PeopleHandlerTest, AcquireSyncBlockerWhenLoadingSyncSettingsSubpage) {
   /// We set up a factory override here to prevent a new web ui from being
   /// created when we navigate to a page that would normally create one.
   web_ui_.set_web_contents(web_contents());
-  test_factory_ = base::MakeUnique<TestChromeWebUIControllerFactory>();
+  test_factory_ = std::make_unique<TestChromeWebUIControllerFactory>();
   test_factory_->AddFactoryOverride(
       chrome::GetSettingsUrl(chrome::kSyncSetupSubPage).host(),
       &test_provider_);
diff --git a/chromium/chrome/browser/ui/webui/settings/printing_handler.h b/chromium/chrome/browser/ui/webui/settings/printing_handler.h
index b233575e578..5759261d684 100644
--- a/chromium/chrome/browser/ui/webui/settings/printing_handler.h
+++ b/chromium/chrome/browser/ui/webui/settings/printing_handler.h
@@ -6,7 +6,17 @@
 #define CHROME_BROWSER_UI_WEBUI_SETTINGS_PRINTING_HANDLER_H_
 
 #include "base/macros.h"
+#include "build/build_config.h"
 #include "chrome/browser/ui/webui/settings/settings_page_ui_handler.h"
+#include "printing/features/features.h"
+
+#if defined(OS_CHROMEOS)
+#error "Not for use on ChromeOS"
+#endif
+
+#if !BUILDFLAG(ENABLE_PRINTING)
+#error "Printing must be enabled"
+#endif
 
 namespace settings {
 
diff --git a/chromium/chrome/browser/ui/webui/settings/profile_info_handler.cc b/chromium/chrome/browser/ui/webui/settings/profile_info_handler.cc
index 304be428702..6261f7f9c28 100644
--- a/chromium/chrome/browser/ui/webui/settings/profile_info_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/profile_info_handler.cc
@@ -5,7 +5,6 @@
 #include "chrome/browser/ui/webui/settings/profile_info_handler.h"
 
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
@@ -203,7 +202,7 @@ ProfileInfoHandler::GetAccountNameAndIcon() const {
   }
 #endif  // defined(OS_CHROMEOS)
 
-  auto response = base::MakeUnique<base::DictionaryValue>();
+  auto response = std::make_unique<base::DictionaryValue>();
   response->SetString("name", name);
   response->SetString("iconUrl", icon_url);
   return response;
diff --git a/chromium/chrome/browser/ui/webui/settings/profile_info_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/profile_info_handler_unittest.cc
index 242ff4b4299..734d9b70fe2 100644
--- a/chromium/chrome/browser/ui/webui/settings/profile_info_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/profile_info_handler_unittest.cc
@@ -182,7 +182,7 @@ TEST_F(ProfileInfoHandlerTest, PushProfileManagesSupervisedUsers) {
       new DictionaryPrefUpdate(profile()->GetPrefs(), prefs::kSupervisedUsers));
   base::DictionaryValue* dict = update->Get();
   dict->SetWithoutPathExpansion("supervised-user-id",
-                                base::MakeUnique<base::DictionaryValue>());
+                                std::make_unique<base::DictionaryValue>());
   update.reset();
 
   EXPECT_EQ(1U, web_ui()->call_data().size());
diff --git a/chromium/chrome/browser/ui/webui/settings/protocol_handlers_handler.cc b/chromium/chrome/browser/ui/webui/settings/protocol_handlers_handler.cc
index 102f8690da7..062d170c0c7 100644
--- a/chromium/chrome/browser/ui/webui/settings/protocol_handlers_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/protocol_handlers_handler.cc
@@ -11,7 +11,6 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -97,7 +96,7 @@ void ProtocolHandlersHandler::GetHandlersForProtocol(
   handlers_value->SetBoolean("has_policy_recommendations",
                              registry->HasPolicyRegisteredHandler(protocol));
 
-  auto handlers_list = base::MakeUnique<base::ListValue>();
+  auto handlers_list = std::make_unique<base::ListValue>();
   GetHandlersAsListValue(registry->GetHandlersFor(protocol),
                          handlers_list.get());
   handlers_value->Set("handlers", std::move(handlers_list));
diff --git a/chromium/chrome/browser/ui/webui/settings/search_engines_handler.cc b/chromium/chrome/browser/ui/webui/settings/search_engines_handler.cc
index 7defa128b45..136df4229c4 100644
--- a/chromium/chrome/browser/ui/webui/settings/search_engines_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/search_engines_handler.cc
@@ -9,7 +9,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/string_number_conversions.h"
@@ -109,7 +108,7 @@ SearchEnginesHandler::GetSearchEnginesList() {
 
   // Build the first list (default search engines).
   std::unique_ptr<base::ListValue> defaults =
-      base::MakeUnique<base::ListValue>();
+      std::make_unique<base::ListValue>();
   int last_default_engine_index =
       list_controller_.table_model()->last_search_engine_index();
   for (int i = 0; i < last_default_engine_index; ++i) {
@@ -118,7 +117,7 @@ SearchEnginesHandler::GetSearchEnginesList() {
   }
 
   // Build the second list (other search engines).
-  std::unique_ptr<base::ListValue> others = base::MakeUnique<base::ListValue>();
+  std::unique_ptr<base::ListValue> others = std::make_unique<base::ListValue>();
   int last_other_engine_index =
       list_controller_.table_model()->last_other_engine_index();
   for (int i = std::max(last_default_engine_index, 0);
@@ -128,7 +127,7 @@ SearchEnginesHandler::GetSearchEnginesList() {
 
   // Build the third list (omnibox extensions).
   std::unique_ptr<base::ListValue> extensions =
-      base::MakeUnique<base::ListValue>();
+      std::make_unique<base::ListValue>();
   int engine_count = list_controller_.table_model()->RowCount();
   for (int i = std::max(last_other_engine_index, 0); i < engine_count; ++i) {
     extensions->Append(CreateDictionaryForEngine(i, i == default_index));
diff --git a/chromium/chrome/browser/ui/webui/settings/settings_clear_browsing_data_handler.cc b/chromium/chrome/browser/ui/webui/settings/settings_clear_browsing_data_handler.cc
index da98085fd22..49cd2fb9f4e 100644
--- a/chromium/chrome/browser/ui/webui/settings/settings_clear_browsing_data_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/settings_clear_browsing_data_handler.cc
@@ -9,15 +9,14 @@
 
 #include "base/feature_list.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_functions.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/metrics/sparse_histogram.h"
 #include "base/values.h"
-#include "chrome/browser/browsing_data/browsing_data_counter_factory.h"
-#include "chrome/browser/browsing_data/browsing_data_counter_utils.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_important_sites_util.h"
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
+#include "chrome/browser/browsing_data/counters/browsing_data_counter_factory.h"
+#include "chrome/browser/browsing_data/counters/browsing_data_counter_utils.h"
 #include "chrome/browser/engagement/important_sites_usage_counter.h"
 #include "chrome/browser/engagement/important_sites_util.h"
 #include "chrome/browser/history/web_history_service_factory.h"
@@ -276,7 +275,7 @@ void ClearBrowsingDataHandler::HandleClearBrowsingData(
                       [&data_types](BrowsingDataType type) {
                         return data_types.find(type) != data_types.end();
                       });
-    UMA_HISTOGRAM_SPARSE_SLOWLY(
+    base::UmaHistogramSparse(
         "History.ClearBrowsingData.PasswordsDeletion.AdditionalDatatypesCount",
         checked_other_types);
   }
@@ -415,7 +414,7 @@ void ClearBrowsingDataHandler::OnFetchImportantSitesFinished(
   base::ListValue important_sites_list;
 
   for (const auto& info : important_sites) {
-    auto entry = base::MakeUnique<base::DictionaryValue>();
+    auto entry = std::make_unique<base::DictionaryValue>();
     entry->SetString(kRegisterableDomainField, info.registerable_domain);
     // The |reason_bitfield| is only passed to Javascript to be logged
     // from |HandleClearBrowsingData|.
diff --git a/chromium/chrome/browser/ui/webui/settings/settings_cookies_view_handler.cc b/chromium/chrome/browser/ui/webui/settings/settings_cookies_view_handler.cc
index a74c0aab4ab..b10325705f8 100644
--- a/chromium/chrome/browser/ui/webui/settings/settings_cookies_view_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/settings_cookies_view_handler.cc
@@ -13,7 +13,6 @@
 #include "base/bind_helpers.h"
 #include "base/i18n/number_formatting.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_appcache_helper.h"
@@ -205,7 +204,7 @@ void CookiesViewHandler::TreeNodesAdded(ui::TreeModel* model,
 
   base::DictionaryValue args;
   if (parent == tree_model->GetRoot())
-    args.Set(kId, base::MakeUnique<base::Value>());
+    args.Set(kId, std::make_unique<base::Value>());
   else
     args.SetString(kId, model_util_->GetTreeNodeId(parent_node));
   args.SetInteger(kStart, start);
@@ -225,7 +224,7 @@ void CookiesViewHandler::TreeNodesRemoved(ui::TreeModel* model,
 
   base::DictionaryValue args;
   if (parent == tree_model->GetRoot())
-    args.Set(kId, base::MakeUnique<base::Value>());
+    args.Set(kId, std::make_unique<base::Value>());
   else
     args.SetString(kId, model_util_->GetTreeNodeId(tree_model->AsNode(parent)));
   args.SetInteger(kStart, start);
@@ -443,15 +442,15 @@ void CookiesViewHandler::SendLocalDataList(const CookieTreeNode* parent) {
       }
     }
     std::unique_ptr<base::DictionaryValue> list_info(new base::DictionaryValue);
-    list_info->Set(kLocalData, base::MakeUnique<base::Value>(description));
+    list_info->Set(kLocalData, std::make_unique<base::Value>(description));
     std::string title = base::UTF16ToUTF8(site->GetTitle());
-    list_info->Set(kSite, base::MakeUnique<base::Value>(title));
+    list_info->Set(kSite, std::make_unique<base::Value>(title));
     site_list->Append(std::move(list_info));
   }
 
   base::DictionaryValue response;
   response.Set(kItems, std::move(site_list));
-  response.Set(kTotal, base::MakeUnique<base::Value>(list_item_count));
+  response.Set(kTotal, std::make_unique<base::Value>(list_item_count));
 
   ResolveJavascriptCallback(base::Value(request_.callback_id_), response);
   request_.Clear();
@@ -467,7 +466,7 @@ void CookiesViewHandler::SendChildren(const CookieTreeNode* parent) {
 
   base::DictionaryValue args;
   if (parent == cookies_tree_model_->GetRoot())
-    args.Set(kId, base::MakeUnique<base::Value>());
+    args.Set(kId, std::make_unique<base::Value>());
   else
     args.SetString(kId, model_util_->GetTreeNodeId(parent));
   args.Set(kChildren, std::move(children));
@@ -487,7 +486,7 @@ void CookiesViewHandler::SendCookieDetails(const CookieTreeNode* parent) {
 
   base::DictionaryValue args;
   if (parent == cookies_tree_model_->GetRoot())
-    args.Set(kId, base::MakeUnique<base::Value>());
+    args.Set(kId, std::make_unique<base::Value>());
   else
     args.SetString(kId, model_util_->GetTreeNodeId(parent));
   args.Set(kChildren, std::move(children));
diff --git a/chromium/chrome/browser/ui/webui/settings/settings_manage_profile_handler.cc b/chromium/chrome/browser/ui/webui/settings/settings_manage_profile_handler.cc
index 8d669c59433..37fc2ac17b3 100644
--- a/chromium/chrome/browser/ui/webui/settings/settings_manage_profile_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/settings_manage_profile_handler.cc
@@ -8,7 +8,6 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -123,7 +122,7 @@ std::unique_ptr<base::ListValue> ManageProfileHandler::GetAvailableIcons() {
           GetProfileAttributesWithPath(profile_->GetPath(), &entry)) {
     const gfx::Image* icon = entry->GetGAIAPicture();
     if (icon) {
-      auto gaia_picture_info = base::MakeUnique<base::DictionaryValue>();
+      auto gaia_picture_info = std::make_unique<base::DictionaryValue>();
       gfx::Image avatar_icon = profiles::GetAvatarIconForWebUI(*icon, true);
       gaia_picture_info->SetString(
           "url", webui::GetBitmapDataUrl(avatar_icon.AsBitmap()));
diff --git a/chromium/chrome/browser/ui/webui/settings/site_settings_handler.cc b/chromium/chrome/browser/ui/webui/settings/site_settings_handler.cc
index 39445a17fa0..0a4b4442f20 100644
--- a/chromium/chrome/browser/ui/webui/settings/site_settings_handler.cc
+++ b/chromium/chrome/browser/ui/webui/settings/site_settings_handler.cc
@@ -45,7 +45,7 @@
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "storage/browser/quota/quota_manager.h"
-#include "storage/common/quota/quota_status_code.h"
+#include "third_party/WebKit/common/quota/quota_types.mojom.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"
 
@@ -214,7 +214,7 @@ void SiteSettingsHandler::OnJavascriptAllowed() {
                          base::Unretained(this)));
 
 #if defined(OS_CHROMEOS)
-  pref_change_registrar_ = base::MakeUnique<PrefChangeRegistrar>();
+  pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
   pref_change_registrar_->Init(profile_->GetPrefs());
   pref_change_registrar_->Add(
       prefs::kEnableDRM,
@@ -242,14 +242,15 @@ void SiteSettingsHandler::OnGetUsageInfo(
       CallJavascriptFunction("settings.WebsiteUsagePrivateApi.returnUsageTotal",
                              base::Value(entry.host),
                              base::Value(ui::FormatBytes(entry.usage)),
-                             base::Value(entry.type));
+                             base::Value(static_cast<int>(entry.type)));
       return;
     }
   }
 }
 
-void SiteSettingsHandler::OnUsageInfoCleared(storage::QuotaStatusCode code) {
-  if (code == storage::kQuotaStatusOk) {
+void SiteSettingsHandler::OnUsageInfoCleared(
+    blink::mojom::QuotaStatusCode code) {
+  if (code == blink::mojom::QuotaStatusCode::kOk) {
     CallJavascriptFunction("settings.WebsiteUsagePrivateApi.onUsageCleared",
                            base::Value(clearing_origin_));
   }
@@ -359,9 +360,9 @@ void SiteSettingsHandler::HandleClearUsage(
         = new StorageInfoFetcher(profile_);
     storage_info_fetcher->ClearStorage(
         url.host(),
-        static_cast<storage::StorageType>(static_cast<int>(storage_type)),
+        static_cast<blink::mojom::StorageType>(static_cast<int>(storage_type)),
         base::Bind(&SiteSettingsHandler::OnUsageInfoCleared,
-            base::Unretained(this)));
+                   base::Unretained(this)));
 
     // Also clear the *local* storage data.
     scoped_refptr<BrowsingDataLocalStorageHelper> local_storage_helper =
@@ -518,7 +519,7 @@ void SiteSettingsHandler::HandleGetOriginPermissions(
 
   // Note: Invalid URLs will just result in default settings being shown.
   const GURL origin_url(origin);
-  auto exceptions = base::MakeUnique<base::ListValue>();
+  auto exceptions = std::make_unique<base::ListValue>();
   for (size_t i = 0; i < types->GetSize(); ++i) {
     std::string type;
     types->GetString(i, &type);
@@ -536,7 +537,7 @@ void SiteSettingsHandler::HandleGetOriginPermissions(
     std::string content_setting_string =
         content_settings::ContentSettingToString(content_setting);
 
-    auto raw_site_exception = base::MakeUnique<base::DictionaryValue>();
+    auto raw_site_exception = std::make_unique<base::DictionaryValue>();
     raw_site_exception->SetString(site_settings::kEmbeddingOrigin, origin);
     raw_site_exception->SetBoolean(site_settings::kIncognito,
                                    profile_->IsOffTheRecord());
diff --git a/chromium/chrome/browser/ui/webui/settings/site_settings_handler.h b/chromium/chrome/browser/ui/webui/settings/site_settings_handler.h
index 460e51d2144..63fa495c22e 100644
--- a/chromium/chrome/browser/ui/webui/settings/site_settings_handler.h
+++ b/chromium/chrome/browser/ui/webui/settings/site_settings_handler.h
@@ -16,6 +16,7 @@
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "third_party/WebKit/common/quota/quota_types.mojom.h"
 
 class HostContentSettingsMap;
 class Profile;
@@ -45,7 +46,7 @@ class SiteSettingsHandler : public SettingsPageUIHandler,
 
   // Usage info.
   void OnGetUsageInfo(const storage::UsageInfoEntries& entries);
-  void OnUsageInfoCleared(storage::QuotaStatusCode code);
+  void OnUsageInfoCleared(blink::mojom::QuotaStatusCode code);
 
 #if defined(OS_CHROMEOS)
   // Alert the Javascript that the |kEnableDRM| pref has changed.
diff --git a/chromium/chrome/browser/ui/webui/settings/site_settings_handler_unittest.cc b/chromium/chrome/browser/ui/webui/settings/site_settings_handler_unittest.cc
index 12c402ef3a3..434947cf2a6 100644
--- a/chromium/chrome/browser/ui/webui/settings/site_settings_handler_unittest.cc
+++ b/chromium/chrome/browser/ui/webui/settings/site_settings_handler_unittest.cc
@@ -61,7 +61,7 @@ class ContentSettingSourceSetter {
 
   void SetPolicyDefault(ContentSetting setting) {
     prefs_->SetManagedPref(GetPrefNameForDefaultPermissionSetting(),
-                           base::MakeUnique<base::Value>(setting));
+                           std::make_unique<base::Value>(setting));
   }
 
   const char* GetPrefNameForDefaultPermissionSetting() {
@@ -373,7 +373,7 @@ TEST_F(SiteSettingsHandlerTest, DefaultSettingSource) {
   base::ListValue get_origin_permissions_args;
   get_origin_permissions_args.AppendString(kCallbackId);
   get_origin_permissions_args.AppendString(google);
-  auto category_list = base::MakeUnique<base::ListValue>();
+  auto category_list = std::make_unique<base::ListValue>();
   category_list->AppendString(kNotifications);
   get_origin_permissions_args.Append(std::move(category_list));
 
@@ -435,7 +435,7 @@ TEST_F(SiteSettingsHandlerTest, GetAndSetOriginPermissions) {
   get_args.AppendString(kCallbackId);
   get_args.AppendString(origin_with_port);
   {
-    auto category_list = base::MakeUnique<base::ListValue>();
+    auto category_list = std::make_unique<base::ListValue>();
     category_list->AppendString(kNotifications);
     get_args.Append(std::move(category_list));
   }
@@ -448,7 +448,7 @@ TEST_F(SiteSettingsHandlerTest, GetAndSetOriginPermissions) {
   base::ListValue set_args;
   set_args.AppendString(origin_with_port);
   {
-    auto category_list = base::MakeUnique<base::ListValue>();
+    auto category_list = std::make_unique<base::ListValue>();
     category_list->AppendString(kNotifications);
     set_args.Append(std::move(category_list));
   }
@@ -460,7 +460,7 @@ TEST_F(SiteSettingsHandlerTest, GetAndSetOriginPermissions) {
   // Reset things back to how they were.
   base::ListValue reset_args;
   reset_args.AppendString(origin_with_port);
-  auto category_list = base::MakeUnique<base::ListValue>();
+  auto category_list = std::make_unique<base::ListValue>();
   category_list->AppendString(kNotifications);
   reset_args.Append(std::move(category_list));
   reset_args.AppendString(
@@ -483,7 +483,7 @@ TEST_F(SiteSettingsHandlerTest, GetAndSetForInvalidURLs) {
   get_args.AppendString(kCallbackId);
   get_args.AppendString(origin);
   {
-    auto category_list = base::MakeUnique<base::ListValue>();
+    auto category_list = std::make_unique<base::ListValue>();
     category_list->AppendString(kNotifications);
     get_args.Append(std::move(category_list));
   }
@@ -498,7 +498,7 @@ TEST_F(SiteSettingsHandlerTest, GetAndSetForInvalidURLs) {
   base::ListValue set_args;
   set_args.AppendString(origin);
   {
-    auto category_list = base::MakeUnique<base::ListValue>();
+    auto category_list = std::make_unique<base::ListValue>();
     category_list->AppendString(kNotifications);
     set_args.Append(std::move(category_list));
   }
@@ -588,7 +588,7 @@ TEST_F(SiteSettingsHandlerTest, ExtensionDisplayName) {
   get_origin_permissions_args.AppendString(kCallbackId);
   get_origin_permissions_args.AppendString(test_extension_url);
   {
-    auto category_list = base::MakeUnique<base::ListValue>();
+    auto category_list = std::make_unique<base::ListValue>();
     category_list->AppendString(kNotifications);
     get_origin_permissions_args.Append(std::move(category_list));
   }
@@ -666,7 +666,7 @@ class SiteSettingsHandlerInfobarTest : public BrowserWithTestWindowTest {
 
   void SetUp() override {
     BrowserWithTestWindowTest::SetUp();
-    handler_ = base::MakeUnique<SiteSettingsHandler>(profile());
+    handler_ = std::make_unique<SiteSettingsHandler>(profile());
     handler()->set_web_ui(web_ui());
     handler()->AllowJavascript();
     web_ui()->ClearTrackedCalls();
@@ -777,7 +777,7 @@ TEST_F(SiteSettingsHandlerInfobarTest, SettingPermissionsTriggersInfobar) {
   base::ListValue set_args;
   set_args.AppendString(origin_anchor_string);
   {
-    auto category_list = base::MakeUnique<base::ListValue>();
+    auto category_list = std::make_unique<base::ListValue>();
     category_list->AppendString(kNotifications);
     set_args.Append(std::move(category_list));
   }
@@ -834,7 +834,7 @@ TEST_F(SiteSettingsHandlerInfobarTest, SettingPermissionsTriggersInfobar) {
   // Reset all permissions.
   base::ListValue reset_args;
   reset_args.AppendString(origin_anchor_string);
-  auto category_list = base::MakeUnique<base::ListValue>();
+  auto category_list = std::make_unique<base::ListValue>();
   category_list->AppendString(kNotifications);
   reset_args.Append(std::move(category_list));
   reset_args.AppendString(