BASELINE: Update Chromium to 65.0.3525.40

Also imports missing submodules Change-Id: I36901b7c6a325cda3d2c10cedb2186c25af3b79b Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
author: Allan Sandfeld Jensen <allan.jensen@qt.io> 2018-01-31 16:33:43 +0100
committer: Allan Sandfeld Jensen <allan.jensen@qt.io> 2018-02-06 16:33:22 +0000
commit: da51f56cc21233c2d30f0fe0d171727c3102b2e0 (patch)
tree: 4e579ab70ce4b19bee7984237f3ce05a96d59d83 /chromium/chrome/browser/extensions/api
parent: c8c2d1901aec01e934adf561a9fdf0cc776cdef8 (diff)
238 files changed, 4805 insertions, 3582 deletions
diff --git a/chromium/chrome/browser/extensions/api/DEPS b/chromium/chrome/browser/extensions/api/DEPS
index a8a4ed7dba8..fea8d34597f 100644
--- a/chromium/chrome/browser/extensions/api/DEPS
+++ b/chromium/chrome/browser/extensions/api/DEPS
@@ -8,6 +8,7 @@ include_rules = [
    # Enable remote assistance on Chrome OS
   "+remoting/base",
   "+remoting/host",
+  "+services/network/public/interfaces",
 ]
 
 specific_include_rules = {
@@ -15,4 +16,10 @@ specific_include_rules = {
     "+chrome/browser/ui/views/frame",
     "+components/captive_portal",
   ],
+
+  # TODO(eladalon): Remove along with webrtc_event_log_apitest.cc.
+  # https://crbug.com/775415
+   "webrtc_event_log_apitest.cc": [
+    "+content/browser/webrtc",
+  ],
 }
diff --git a/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api.cc b/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api.cc
index cded076a9bb..ab0b80cca93 100644
--- a/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api.cc
@@ -96,7 +96,7 @@ void ActivityLogAPI::OnExtensionActivity(scoped_refptr<Action> activity) {
   std::unique_ptr<base::ListValue> value(new base::ListValue());
   ExtensionActivity activity_arg = activity->ConvertToExtensionActivity();
   value->Append(activity_arg.ToValue());
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::ACTIVITY_LOG_PRIVATE_ON_EXTENSION_ACTIVITY,
       activity_log_private::OnExtensionActivity::kEventName, std::move(value),
       browser_context_);
diff --git a/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api_unittest.cc b/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api_unittest.cc
index e26a1bd0031..e9b027c2ee9 100644
--- a/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/activity_log_private/activity_log_private_api_unittest.cc
@@ -8,7 +8,6 @@
 #include <string>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/activity_log/activity_action_constants.h"
@@ -30,8 +29,8 @@ typedef testing::Test ActivityLogApiUnitTest;
 
 TEST_F(ActivityLogApiUnitTest, ConvertChromeApiAction) {
   std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Set(0, base::MakeUnique<base::Value>("hello"));
-  args->Set(1, base::MakeUnique<base::Value>("world"));
+  args->Set(0, std::make_unique<base::Value>("hello"));
+  args->Set(1, std::make_unique<base::Value>("world"));
   scoped_refptr<Action> action(new Action(kExtensionId,
                                           base::Time::Now(),
                                           Action::ACTION_API_CALL,
@@ -48,8 +47,8 @@ TEST_F(ActivityLogApiUnitTest, ConvertChromeApiAction) {
 
 TEST_F(ActivityLogApiUnitTest, ConvertDomAction) {
   std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Set(0, base::MakeUnique<base::Value>("hello"));
-  args->Set(1, base::MakeUnique<base::Value>("world"));
+  args->Set(0, std::make_unique<base::Value>("hello"));
+  args->Set(1, std::make_unique<base::Value>("world"));
   scoped_refptr<Action> action(new Action(kExtensionId,
                                base::Time::Now(),
                                Action::ACTION_DOM_ACCESS,
diff --git a/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_api.cc b/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_api.cc
index c3fbbfe0193..76fa90e5d6f 100644
--- a/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_api.cc
@@ -186,8 +186,20 @@ ExtensionFunction::ResponseAction AutofillPrivateSaveAddressFunction::Run() {
 
   api::autofill_private::AddressEntry* address = &parameters->address;
 
+  // If a profile guid is specified, get a copy of the profile identified by it.
+  // Otherwise create a new one.
   std::string guid = address->guid ? *address->guid : "";
-  autofill::AutofillProfile profile(guid, kSettingsOrigin);
+  const bool use_existing_profile = !guid.empty();
+  const autofill::AutofillProfile* existing_profile = nullptr;
+  if (use_existing_profile) {
+    existing_profile = personal_data->GetProfileByGUID(guid);
+    if (!existing_profile)
+      return RespondNow(Error(kErrorDataUnavailable));
+  }
+  autofill::AutofillProfile profile =
+      existing_profile
+          ? *existing_profile
+          : autofill::AutofillProfile(base::GenerateGUID(), kSettingsOrigin);
 
   // Strings from JavaScript use UTF-8 encoding. This container is used as an
   // intermediate container for functions which require UTF-16 strings.
@@ -268,11 +280,10 @@ ExtensionFunction::ResponseAction AutofillPrivateSaveAddressFunction::Run() {
   if (address->language_code)
     profile.set_language_code(*address->language_code);
 
-  if (!base::IsValidGUID(profile.guid())) {
-    profile.set_guid(base::GenerateGUID());
-    personal_data->AddProfile(profile);
-  } else {
+  if (use_existing_profile) {
     personal_data->UpdateProfile(profile);
+  } else {
+    personal_data->AddProfile(profile);
   }
 
   return RespondNow(NoArguments());
@@ -373,8 +384,20 @@ ExtensionFunction::ResponseAction AutofillPrivateSaveCreditCardFunction::Run() {
 
   api::autofill_private::CreditCardEntry* card = &parameters->card;
 
+  // If a card guid is specified, get a copy of the card identified by it.
+  // Otherwise create a new one.
   std::string guid = card->guid ? *card->guid : "";
-  autofill::CreditCard credit_card(guid, kSettingsOrigin);
+  const bool use_existing_card = !guid.empty();
+  const autofill::CreditCard* existing_card = nullptr;
+  if (use_existing_card) {
+    existing_card = personal_data->GetCreditCardByGUID(guid);
+    if (!existing_card)
+      return RespondNow(Error(kErrorDataUnavailable));
+  }
+  autofill::CreditCard credit_card =
+      existing_card
+          ? *existing_card
+          : autofill::CreditCard(base::GenerateGUID(), kSettingsOrigin);
 
   if (card->name) {
     credit_card.SetRawInfo(autofill::CREDIT_CARD_NAME_FULL,
@@ -399,15 +422,10 @@ ExtensionFunction::ResponseAction AutofillPrivateSaveCreditCardFunction::Run() {
         base::UTF8ToUTF16(*card->expiration_year));
   }
 
-  if (card->billing_address_id) {
-    credit_card.set_billing_address_id(*card->billing_address_id);
-  }
-
-  if (!base::IsValidGUID(credit_card.guid())) {
-    credit_card.set_guid(base::GenerateGUID());
-    personal_data->AddCreditCard(credit_card);
-  } else {
+  if (use_existing_card) {
     personal_data->UpdateCreditCard(credit_card);
+  } else {
+    personal_data->AddCreditCard(credit_card);
   }
 
   return RespondNow(NoArguments());
diff --git a/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_apitest.cc b/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_apitest.cc
index 82a29234514..11c0196db93 100644
--- a/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/autofill_private/autofill_private_apitest.cc
@@ -45,11 +45,6 @@ class AutofillPrivateApiTest : public ExtensionApiTest {
 // TODO(hcarmona): Investigate converting these tests to unittests.
 
 // TODO(crbug.com/643097) Disabled for flakiness.
-IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, DISABLED_SaveAddress) {
-  EXPECT_TRUE(RunAutofillSubtest("saveAddress")) << message_;
-}
-
-// TODO(crbug.com/643097) Disabled for flakiness.
 IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, DISABLED_GetCountryList) {
   EXPECT_TRUE(RunAutofillSubtest("getCountryList")) << message_;
 }
@@ -59,11 +54,6 @@ IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, GetAddressComponents) {
 }
 
 // TODO(crbug.com/643097) Disabled for flakiness.
-IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, DISABLED_SaveCreditCard) {
-  EXPECT_TRUE(RunAutofillSubtest("saveCreditCard")) << message_;
-}
-
-// TODO(crbug.com/643097) Disabled for flakiness.
 IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, DISABLED_RemoveEntry) {
   EXPECT_TRUE(RunAutofillSubtest("removeEntry")) << message_;
 }
@@ -72,5 +62,13 @@ IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, ValidatePhoneNumbers) {
   EXPECT_TRUE(RunAutofillSubtest("ValidatePhoneNumbers")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, AddAndUpdateAddress) {
+  EXPECT_TRUE(RunAutofillSubtest("addAndUpdateAddress")) << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(AutofillPrivateApiTest, AddAndUpdateCreditCard) {
+  EXPECT_TRUE(RunAutofillSubtest("addAndUpdateCreditCard")) << message_;
+}
+
 }  // namespace extensions
 
diff --git a/chromium/chrome/browser/extensions/api/autofill_private/autofill_util.cc b/chromium/chrome/browser/extensions/api/autofill_private/autofill_util.cc
index 9bc56f0c404..2f3640b72fa 100644
--- a/chromium/chrome/browser/extensions/api/autofill_private/autofill_util.cc
+++ b/chromium/chrome/browser/extensions/api/autofill_private/autofill_util.cc
@@ -9,7 +9,6 @@
 #include <utility>
 #include <vector>
 
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
@@ -63,7 +62,7 @@ std::unique_ptr<std::vector<std::string>> GetValueList(
 std::unique_ptr<std::string> GetStringFromProfile(
     const autofill::AutofillProfile& profile,
     const autofill::ServerFieldType& type) {
-  return base::MakeUnique<std::string>(
+  return std::make_unique<std::string>(
       base::UTF16ToUTF8(profile.GetRawInfo(type)));
 }
 
@@ -146,8 +145,6 @@ autofill_private::CreditCardEntry CreditCardToCreditCardEntry(
       credit_card.GetRawInfo(autofill::CREDIT_CARD_EXP_MONTH))));
   card.expiration_year.reset(new std::string(base::UTF16ToUTF8(
       credit_card.GetRawInfo(autofill::CREDIT_CARD_EXP_4_DIGIT_YEAR))));
-  card.billing_address_id.reset(
-      new std::string(credit_card.billing_address_id()));
 
   // Create address metadata and add it to |address|.
   std::unique_ptr<autofill_private::AutofillMetadata> metadata(
diff --git a/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc b/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc
index ede22c2cbf9..81b27277daa 100644
--- a/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc
@@ -281,7 +281,7 @@ IN_PROC_BROWSER_TEST_F(AutomationApiTest, Find) {
 }
 
 // TODO(crbug.com/725420) Flaky
-IN_PROC_BROWSER_TEST_F(AutomationApiTest, DISABLED_Attributes) {
+IN_PROC_BROWSER_TEST_F(AutomationApiTest, Attributes) {
   StartEmbeddedTestServer();
   ASSERT_TRUE(RunExtensionSubtest("automation/tests/tabs", "attributes.html"))
       << message_;
@@ -329,6 +329,12 @@ IN_PROC_BROWSER_TEST_F(AutomationApiTestWithDeviceScaleFactor, LocationScaled) {
       << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(AutomationApiTestWithDeviceScaleFactor, HitTest) {
+  StartEmbeddedTestServer();
+  ASSERT_TRUE(RunExtensionSubtest("automation/tests/desktop", "hit_test.html"))
+      << message_;
+}
+
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.cc b/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.cc
index 0c20f404c84..b54484f9b58 100644
--- a/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.cc
+++ b/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.cc
@@ -49,22 +49,18 @@ AutomationEventRouter::~AutomationEventRouter() {
 void AutomationEventRouter::RegisterListenerForOneTree(
     const ExtensionId& extension_id,
     int listener_process_id,
-    int listener_routing_id,
     int source_ax_tree_id) {
   Register(extension_id,
            listener_process_id,
-           listener_routing_id,
            source_ax_tree_id,
            false);
 }
 
 void AutomationEventRouter::RegisterListenerWithDesktopPermission(
     const ExtensionId& extension_id,
-    int listener_process_id,
-    int listener_routing_id) {
+    int listener_process_id) {
   Register(extension_id,
            listener_process_id,
-           listener_routing_id,
            api::automation::kDesktopTreeID,
            true);
 }
@@ -85,8 +81,7 @@ void AutomationEventRouter::DispatchAccessibilityEvent(
 
     content::RenderProcessHost* rph =
         content::RenderProcessHost::FromID(listener.process_id);
-    rph->Send(new ExtensionMsg_AccessibilityEvent(listener.routing_id,
-                                                  params,
+    rph->Send(new ExtensionMsg_AccessibilityEvent(params,
                                                   listener.is_active_profile));
   }
 }
@@ -102,9 +97,7 @@ void AutomationEventRouter::DispatchAccessibilityLocationChange(
 
     content::RenderProcessHost* rph =
         content::RenderProcessHost::FromID(listener.process_id);
-    rph->Send(new ExtensionMsg_AccessibilityLocationChange(
-        listener.routing_id,
-        params));
+    rph->Send(new ExtensionMsg_AccessibilityLocationChange(params));
   }
 }
 
@@ -117,7 +110,7 @@ void AutomationEventRouter::DispatchTreeDestroyedEvent(
   browser_context = browser_context ? browser_context : active_profile_;
   std::unique_ptr<base::ListValue> args(
       api::automation_internal::OnAccessibilityTreeDestroyed::Create(tree_id));
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::AUTOMATION_INTERNAL_ON_ACCESSIBILITY_TREE_DESTROYED,
       api::automation_internal::OnAccessibilityTreeDestroyed::kEventName,
       std::move(args), browser_context);
@@ -134,7 +127,7 @@ void AutomationEventRouter::DispatchActionResult(const ui::AXActionData& data,
   std::unique_ptr<base::ListValue> args(
       api::automation_internal::OnActionResult::Create(
           data.target_tree_id, data.request_id, result));
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::AUTOMATION_INTERNAL_ON_ACTION_RESULT,
       api::automation_internal::OnActionResult::kEventName, std::move(args),
       active_profile_);
@@ -154,23 +147,18 @@ AutomationEventRouter::AutomationListener::~AutomationListener() {
 void AutomationEventRouter::Register(
     const ExtensionId& extension_id,
     int listener_process_id,
-    int listener_routing_id,
     int ax_tree_id,
     bool desktop) {
-  auto iter = std::find_if(
-      listeners_.begin(),
-      listeners_.end(),
-      [listener_process_id, listener_routing_id](
-          const AutomationListener& item) {
-        return (item.process_id == listener_process_id &&
-                item.routing_id == listener_routing_id);
-      });
-
-  // Add a new entry if we don't have one with that process and routing id.
+  auto iter =
+      std::find_if(listeners_.begin(), listeners_.end(),
+                   [listener_process_id](const AutomationListener& item) {
+                     return item.process_id == listener_process_id;
+                   });
+
+  // Add a new entry if we don't have one with that process.
   if (iter == listeners_.end()) {
     AutomationListener listener;
     listener.extension_id = extension_id;
-    listener.routing_id = listener_routing_id;
     listener.process_id = listener_process_id;
     listener.desktop = desktop;
     listener.tree_ids.insert(ax_tree_id);
@@ -179,8 +167,8 @@ void AutomationEventRouter::Register(
     return;
   }
 
-  // We have an entry with that process and routing id, so update the set of
-  // tree ids it wants to listen to, and update its desktop permission.
+  // We have an entry with that process so update the set of tree ids it wants
+  // to listen to, and update its desktop permission.
   iter->tree_ids.insert(ax_tree_id);
   if (desktop)
     iter->desktop = true;
diff --git a/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.h b/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.h
index 426d2646568..6e9d14aff5e 100644
--- a/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.h
+++ b/chromium/chrome/browser/extensions/api/automation_internal/automation_event_router.h
@@ -36,21 +36,19 @@ class AutomationEventRouter : public content::NotificationObserver {
  public:
   static AutomationEventRouter* GetInstance();
 
-  // Indicates that the listener at |listener_process_id|, |listener_routing_id|
-  // wants to receive automation events from the accessibility tree indicated
-  // by |source_ax_tree_id|. Automation events are forwarded from now on
-  // until the listener process dies.
+  // Indicates that the listener at |listener_process_id| wants to receive
+  // automation events from the accessibility tree indicated by
+  // |source_ax_tree_id|. Automation events are forwarded from now on until the
+  // listener process dies.
   void RegisterListenerForOneTree(const ExtensionId& extension_id,
                                   int listener_process_id,
-                                  int listener_routing_id,
                                   int source_ax_tree_id);
 
-  // Indicates that the listener at |listener_process_id|, |listener_routing_id|
-  // wants to receive automation events from all accessibility trees because
-  // it has Desktop permission.
+  // Indicates that the listener at |listener_process_id| wants to receive
+  // automation events from all accessibility trees because it has Desktop
+  // permission.
   void RegisterListenerWithDesktopPermission(const ExtensionId& extension_id,
-                                             int listener_process_id,
-                                             int listener_routing_id);
+                                             int listener_process_id);
 
   void DispatchAccessibilityEvent(
       const ExtensionMsg_AccessibilityEventParams& params);
@@ -74,7 +72,6 @@ class AutomationEventRouter : public content::NotificationObserver {
     ~AutomationListener();
 
     ExtensionId extension_id;
-    int routing_id;
     int process_id;
     bool desktop;
     std::set<int> tree_ids;
@@ -87,7 +84,6 @@ class AutomationEventRouter : public content::NotificationObserver {
   void Register(
       const ExtensionId& extension_id,
       int listener_process_id,
-      int listener_routing_id,
       int source_ax_tree_id,
       bool desktop);
 
diff --git a/chromium/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc b/chromium/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc
index 20fcf5a0064..c468f587436 100644
--- a/chromium/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc
+++ b/chromium/chrome/browser/extensions/api/automation_internal/automation_internal_api.cc
@@ -10,7 +10,6 @@
 #include <vector>
 
 #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/utf_string_conversions.h"
@@ -173,6 +172,7 @@ class AutomationWebContentsObserver
       params.event_type = event.event_type;
       params.update = event.update;
       params.event_from = event.event_from;
+      params.action_request_id = event.action_request_id;
 #if defined(USE_AURA)
       params.mouse_location = aura::Env::GetInstance()->last_mouse_location();
 #endif
@@ -295,7 +295,6 @@ AutomationInternalEnableTabFunction::Run() {
   AutomationEventRouter::GetInstance()->RegisterListenerForOneTree(
       extension_id(),
       source_process_id(),
-      params->args.routing_id,
       ax_tree_id);
 
   return RespondNow(ArgumentList(
@@ -497,15 +496,9 @@ AutomationInternalEnableDesktopFunction::Run() {
   if (!automation_info || !automation_info->desktop)
     return RespondNow(Error("desktop permission must be requested"));
 
-  using api::automation_internal::EnableDesktop::Params;
-  std::unique_ptr<Params> params(Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-
   // This gets removed when the extension process dies.
   AutomationEventRouter::GetInstance()->RegisterListenerWithDesktopPermission(
-      extension_id(),
-      source_process_id(),
-      params->routing_id);
+      extension_id(), source_process_id());
 
   AutomationManagerAura::GetInstance()->Enable(browser_context());
   return RespondNow(NoArguments());
@@ -555,7 +548,7 @@ void AutomationInternalQuerySelectorFunction::OnResponse(
     return;
   }
 
-  Respond(OneArgument(base::MakeUnique<base::Value>(result_acc_obj_id)));
+  Respond(OneArgument(std::make_unique<base::Value>(result_acc_obj_id)));
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.cc b/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.cc
index b01bc990d6a..7a2179a278f 100644
--- a/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.cc
@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ -32,8 +31,10 @@
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/system/input_device_settings.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/ash/login_screen_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
+#include "chromeos/printing/printer_configuration.h"
 #include "components/user_manager/user_manager.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
@@ -49,7 +50,7 @@ std::unique_ptr<base::ListValue> GetHostPermissions(const Extension* ext,
       effective_perm ? permissions_data->GetEffectiveHostPermissions()
                      : permissions_data->active_permissions().explicit_hosts();
 
-  auto permissions = base::MakeUnique<base::ListValue>();
+  auto permissions = std::make_unique<base::ListValue>();
   for (URLPatternSet::const_iterator perm = pattern_set.begin();
        perm != pattern_set.end();
        ++perm) {
@@ -60,7 +61,7 @@ std::unique_ptr<base::ListValue> GetHostPermissions(const Extension* ext,
 }
 
 std::unique_ptr<base::ListValue> GetAPIPermissions(const Extension* ext) {
-  auto permissions = base::MakeUnique<base::ListValue>();
+  auto permissions = std::make_unique<base::ListValue>();
   std::set<std::string> perm_list =
       ext->permissions_data()->active_permissions().GetAPIsAsStrings();
   for (std::set<std::string>::const_iterator perm = perm_list.begin();
@@ -105,17 +106,32 @@ ExtensionFunction::ResponseAction AutotestPrivateShutdownFunction::Run() {
 ExtensionFunction::ResponseAction AutotestPrivateLoginStatusFunction::Run() {
   DVLOG(1) << "AutotestPrivateLoginStatusFunction";
 
-  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 #if defined(OS_CHROMEOS)
+  LoginScreenClient::Get()->IsReadyForPassword(base::BindOnce(
+      &AutotestPrivateLoginStatusFunction::OnIsReadyForPassword, this));
+  return RespondLater();
+#else
+  return RespondNow(OneArgument(std::make_unique<base::DictionaryValue>()));
+#endif
+}
+
+#if defined(OS_CHROMEOS)
+void AutotestPrivateLoginStatusFunction::OnIsReadyForPassword(bool is_ready) {
+  auto result = std::make_unique<base::DictionaryValue>();
   const user_manager::UserManager* user_manager =
       user_manager::UserManager::Get();
+
+  // default_screen_locker()->locked() is set when the UI is ready, so this
+  // tells us both views based lockscreen UI and screenlocker are ready.
   const bool is_screen_locked =
-      !!chromeos::ScreenLocker::default_screen_locker();
+      !!chromeos::ScreenLocker::default_screen_locker() &&
+      chromeos::ScreenLocker::default_screen_locker()->locked();
 
   if (user_manager) {
     result->SetBoolean("isLoggedIn", user_manager->IsUserLoggedIn());
     result->SetBoolean("isOwner", user_manager->IsCurrentUserOwner());
     result->SetBoolean("isScreenLocked", is_screen_locked);
+    result->SetBoolean("isReadyForPassword", is_ready);
     if (user_manager->IsUserLoggedIn()) {
       result->SetBoolean("isRegularUser",
                          user_manager->IsLoggedInAsUserWithGaiaAccount());
@@ -143,10 +159,9 @@ ExtensionFunction::ResponseAction AutotestPrivateLoginStatusFunction::Run() {
       result->SetString("userImage", user_image);
     }
   }
-#endif
-
-  return RespondNow(OneArgument(std::move(result)));
+  Respond(OneArgument(std::move(result)));
 }
+#endif
 
 ExtensionFunction::ResponseAction AutotestPrivateLockScreenFunction::Run() {
   DVLOG(1) << "AutotestPrivateLockScreenFunction";
@@ -169,7 +184,7 @@ AutotestPrivateGetExtensionsInfoFunction::Run() {
   ExtensionActionManager* extension_action_manager =
       ExtensionActionManager::Get(browser_context());
 
-  auto extensions_values = base::MakeUnique<base::ListValue>();
+  auto extensions_values = std::make_unique<base::ListValue>();
   ExtensionList all;
   all.insert(all.end(), extensions.begin(), extensions.end());
   all.insert(all.end(), disabled_extensions.begin(), disabled_extensions.end());
@@ -383,7 +398,7 @@ AutotestPrivateGetVisibleNotificationsFunction::Run() {
 #if defined(OS_CHROMEOS)
   for (auto* notification :
        message_center::MessageCenter::Get()->GetVisibleNotifications()) {
-    auto result = base::MakeUnique<base::DictionaryValue>();
+    auto result = std::make_unique<base::DictionaryValue>();
     result->SetString("id", notification->id());
     result->SetString("type", ConvertToString(notification->type()));
     result->SetString("title", notification->title());
@@ -397,6 +412,51 @@ AutotestPrivateGetVisibleNotificationsFunction::Run() {
   return RespondNow(OneArgument(std::move(values)));
 }
 
+#if defined(OS_CHROMEOS)
+// static
+std::string AutotestPrivateGetPrinterListFunction::GetPrinterType(
+    chromeos::CupsPrintersManager::PrinterClass type) {
+  switch (type) {
+    case chromeos::CupsPrintersManager::PrinterClass::kConfigured:
+      return "configured";
+    case chromeos::CupsPrintersManager::PrinterClass::kEnterprise:
+      return "enterprise";
+    case chromeos::CupsPrintersManager::PrinterClass::kAutomatic:
+      return "automatic";
+    case chromeos::CupsPrintersManager::PrinterClass::kDiscovered:
+      return "discovered";
+    default:
+      return "unknown";
+  }
+}
+#endif
+
+ExtensionFunction::ResponseAction AutotestPrivateGetPrinterListFunction::Run() {
+  DVLOG(1) << "AutotestPrivateGetPrinterListFunction";
+  auto values = std::make_unique<base::ListValue>();
+#if defined(OS_CHROMEOS)
+  Profile* profile = ProfileManager::GetActiveUserProfile();
+  std::unique_ptr<chromeos::CupsPrintersManager> printers_manager =
+      chromeos::CupsPrintersManager::Create(profile);
+  std::vector<chromeos::CupsPrintersManager::PrinterClass> printer_type = {
+      chromeos::CupsPrintersManager::PrinterClass::kConfigured,
+      chromeos::CupsPrintersManager::PrinterClass::kEnterprise,
+      chromeos::CupsPrintersManager::PrinterClass::kAutomatic};
+  for (const auto& type : printer_type) {
+    std::vector<chromeos::Printer> printer_list =
+        printers_manager->GetPrinters(type);
+    for (const auto& printer : printer_list) {
+      auto result = std::make_unique<base::DictionaryValue>();
+      result->SetString("printerName", printer.display_name());
+      result->SetString("printerId", printer.id());
+      result->SetString("printerType", GetPrinterType(type));
+      values->Append(std::move(result));
+    }
+  }
+#endif
+  return RespondNow(OneArgument(std::move(values)));
+}
+
 ExtensionFunction::ResponseAction
 AutotestPrivateGetPlayStoreStateFunction::Run() {
   DVLOG(1) << "AutotestPrivateGetPlayStoreStateFunction";
@@ -407,8 +467,8 @@ AutotestPrivateGetPlayStoreStateFunction::Run() {
   if (arc::IsArcAllowedForProfile(profile)) {
     play_store_state.allowed = true;
     play_store_state.enabled =
-        base::MakeUnique<bool>(arc::IsArcPlayStoreEnabledForProfile(profile));
-    play_store_state.managed = base::MakeUnique<bool>(
+        std::make_unique<bool>(arc::IsArcPlayStoreEnabledForProfile(profile));
+    play_store_state.managed = std::make_unique<bool>(
         arc::IsArcPlayStoreEnabledPreferenceManagedForProfile(profile));
   }
 #endif
diff --git a/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.h b/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.h
index e781e181aa9..7f55a387113 100644
--- a/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.h
+++ b/chromium/chrome/browser/extensions/api/autotest_private/autotest_private_api.h
@@ -12,6 +12,10 @@
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "ui/message_center/notification_types.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/printing/cups_printers_manager.h"
+#endif
+
 namespace extensions {
 
 class AutotestPrivateLogoutFunction : public UIThreadExtensionFunction {
@@ -50,6 +54,10 @@ class AutotestPrivateLoginStatusFunction : public UIThreadExtensionFunction {
  private:
   ~AutotestPrivateLoginStatusFunction() override {}
   ResponseAction Run() override;
+
+#if defined(OS_CHROMEOS)
+  void OnIsReadyForPassword(bool is_ready);
+#endif
 };
 
 class AutotestPrivateLockScreenFunction : public UIThreadExtensionFunction {
@@ -205,6 +213,23 @@ class AutotestPrivateSetPlayStoreEnabledFunction
   ResponseAction Run() override;
 };
 
+class AutotestPrivateGetPrinterListFunction : public UIThreadExtensionFunction {
+ public:
+  AutotestPrivateGetPrinterListFunction() = default;
+  DECLARE_EXTENSION_FUNCTION("autotestPrivate.getPrinterList",
+                             AUTOTESTPRIVATE_GETPRINTERLIST)
+
+ private:
+#if defined(OS_CHROMEOS)
+  static std::string GetPrinterType(
+      chromeos::CupsPrintersManager::PrinterClass type);
+#endif
+  ~AutotestPrivateGetPrinterListFunction() override = default;
+  ResponseAction Run() override;
+
+  DISALLOW_COPY_AND_ASSIGN(AutotestPrivateGetPrinterListFunction);
+};
+
 // Don't kill the browser when we're in a browser test.
 void SetAutotestPrivateTest();
 
diff --git a/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc b/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc
index 0d1ebac9e7d..bdc5848ab26 100644
--- a/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_api.cc
@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ -193,7 +192,7 @@ void BookmarkManagerPrivateEventRouter::DispatchEvent(
     const std::string& event_name,
     std::unique_ptr<base::ListValue> event_args) {
   EventRouter::Get(browser_context_)
-      ->BroadcastEvent(base::MakeUnique<Event>(histogram_value, event_name,
+      ->BroadcastEvent(std::make_unique<Event>(histogram_value, event_name,
                                                std::move(event_args)));
 }
 
@@ -438,7 +437,7 @@ bool BookmarkManagerPrivateCanPasteFunction::RunOnReady() {
 
   PrefService* prefs = user_prefs::UserPrefs::Get(GetProfile());
   if (!prefs->GetBoolean(bookmarks::prefs::kEditBookmarksEnabled)) {
-    SetResult(base::MakeUnique<base::Value>(false));
+    SetResult(std::make_unique<base::Value>(false));
     return true;
   }
 
@@ -450,7 +449,7 @@ bool BookmarkManagerPrivateCanPasteFunction::RunOnReady() {
     return false;
   }
   bool can_paste = bookmarks::CanPasteFromClipboard(model, parent_node);
-  SetResult(base::MakeUnique<base::Value>(can_paste));
+  SetResult(std::make_unique<base::Value>(can_paste));
   return true;
 }
 
@@ -654,7 +653,7 @@ bool BookmarkManagerPrivateGetSubtreeFunction::RunOnReady() {
 
 bool BookmarkManagerPrivateCanEditFunction::RunOnReady() {
   PrefService* prefs = user_prefs::UserPrefs::Get(GetProfile());
-  SetResult(base::MakeUnique<base::Value>(
+  SetResult(std::make_unique<base::Value>(
       prefs->GetBoolean(bookmarks::prefs::kEditBookmarksEnabled)));
   return true;
 }
diff --git a/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc b/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc
index b0f1c361663..eab6d93f5cd 100644
--- a/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc
@@ -47,7 +47,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_BookmarkManager) {
   list.Append(std::move(node));
   node.reset(new base::DictionaryValue());
   node->SetString("name", "Managed Folder");
-  node->Set("children", base::MakeUnique<base::ListValue>());
+  node->Set("children", std::make_unique<base::ListValue>());
   list.Append(std::move(node));
   profile->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list);
   ASSERT_EQ(2, managed->managed_node()->child_count());
diff --git a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
index c4193769c2e..0afc0ab363f 100644
--- a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
@@ -6,10 +6,10 @@
 
 #include <math.h>  // For floor()
 
+#include <memory>
 #include <utility>
 #include <vector>
 
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ -153,7 +153,7 @@ void GetMetaInfo(const BookmarkNode& node,
     return;
 
   const BookmarkNode::MetaInfoMap* meta_info = node.GetMetaInfoMap();
-  auto value = base::MakeUnique<base::DictionaryValue>();
+  auto value = std::make_unique<base::DictionaryValue>();
   if (meta_info) {
     BookmarkNode::MetaInfoMap::const_iterator itr;
     for (itr = meta_info->begin(); itr != meta_info->end(); ++itr) {
diff --git a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
index 46b1c776d0b..8717bf94ac3 100644
--- a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
@@ -5,7 +5,6 @@
 #include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
@@ -44,7 +43,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_Bookmarks) {
   list.Append(std::move(node));
   node.reset(new base::DictionaryValue());
   node->SetString("name", "Managed Folder");
-  node->Set("children", base::MakeUnique<base::ListValue>());
+  node->Set("children", std::make_unique<base::ListValue>());
   list.Append(std::move(node));
   profile->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list);
   ASSERT_EQ(2, managed->managed_node()->child_count());
diff --git a/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc b/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
index 7ba7a25d4f8..397e6f924bf 100644
--- a/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
+++ b/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
@@ -14,7 +14,6 @@
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
@@ -263,7 +262,7 @@ void BookmarkEventRouter::DispatchEvent(
     std::unique_ptr<base::ListValue> event_args) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (event_router) {
-    event_router->BroadcastEvent(base::MakeUnique<extensions::Event>(
+    event_router->BroadcastEvent(std::make_unique<extensions::Event>(
         histogram_value, event_name, std::move(event_args)));
   }
 }
diff --git a/chromium/chrome/browser/extensions/api/cast_streaming/cast_streaming_apitest.cc b/chromium/chrome/browser/extensions/api/cast_streaming/cast_streaming_apitest.cc
index 31e0aa8abb2..9c15fa49d72 100644
--- a/chromium/chrome/browser/extensions/api/cast_streaming/cast_streaming_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/cast_streaming/cast_streaming_apitest.cc
@@ -204,7 +204,7 @@ class TestPatternReceiver : public media::cast::InProcessReceiver {
 
     CHECK(video_frame->format() == media::PIXEL_FORMAT_YV12 ||
           video_frame->format() == media::PIXEL_FORMAT_I420 ||
-          video_frame->format() == media::PIXEL_FORMAT_YV12A);
+          video_frame->format() == media::PIXEL_FORMAT_I420A);
 
     if (done_callback_.is_null() || expected_yuv_colors_.empty())
       return;  // No need to waste CPU doing analysis on the frame.
diff --git a/chromium/chrome/browser/extensions/api/cast_streaming/performance_test.cc b/chromium/chrome/browser/extensions/api/cast_streaming/performance_test.cc
index d505f8b2ffb..8a53d8a19aa 100644
--- a/chromium/chrome/browser/extensions/api/cast_streaming/performance_test.cc
+++ b/chromium/chrome/browser/extensions/api/cast_streaming/performance_test.cc
@@ -104,26 +104,25 @@ media::cast::FrameReceiverConfig WithAesKeyAndIvSet(
 
 class SkewedCastEnvironment : public media::cast::StandaloneCastEnvironment {
  public:
-  explicit SkewedCastEnvironment(const base::TimeDelta& delta) :
-      StandaloneCastEnvironment() {
-    auto skewed_clock =
-        base::MakeUnique<media::cast::test::SkewedTickClock>(&default_clock_);
+  explicit SkewedCastEnvironment(const base::TimeDelta& delta)
+      : StandaloneCastEnvironment(),
+        skewed_clock_(base::DefaultTickClock::GetInstance()) {
     // If testing with a receiver clock that is ahead or behind the sender
     // clock, fake a clock that is offset and also ticks at a rate of 50 parts
     // per million faster or slower than the local sender's clock. This is the
     // worst-case scenario for skew in-the-wild.
     if (!delta.is_zero()) {
       const double skew = delta < base::TimeDelta() ? 0.999950 : 1.000050;
-      skewed_clock->SetSkew(skew, delta);
+      skewed_clock_.SetSkew(skew, delta);
     }
-    clock_ = std::move(skewed_clock);
+    clock_ = &skewed_clock_;
   }
 
  protected:
   ~SkewedCastEnvironment() override {}
 
  private:
-  base::DefaultTickClock default_clock_;
+  media::cast::test::SkewedTickClock skewed_clock_;
 };
 
 // We log one of these for each call to OnAudioFrame/OnVideoFrame.
diff --git a/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc b/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc
index 4b792356c9a..ce4780596da 100644
--- a/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc
+++ b/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_api.cc
@@ -11,7 +11,6 @@
 #include <vector>
 
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_provider_service.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_provider_service_factory.h"
 #include "chrome/common/extensions/api/certificate_provider.h"
@@ -139,9 +138,8 @@ bool CertificateProviderInternalReportCertificatesFunction::
   size_t public_key_length_in_bits = 0;
   net::X509Certificate::PublicKeyType type =
       net::X509Certificate::kPublicKeyTypeUnknown;
-  net::X509Certificate::GetPublicKeyInfo(
-      out_info->certificate->os_cert_handle(), &public_key_length_in_bits,
-      &type);
+  net::X509Certificate::GetPublicKeyInfo(out_info->certificate->cert_buffer(),
+                                         &public_key_length_in_bits, &type);
 
   switch (type) {
     case net::X509Certificate::kPublicKeyTypeRSA:
@@ -258,7 +256,7 @@ void CertificateProviderRequestPinFunction::GetQuotaLimitHeuristics(
   QuotaLimitHeuristic::Config short_limit_config = {
       api::certificate_provider::kMaxClosedDialogsPer10Mins,
       base::TimeDelta::FromMinutes(10)};
-  heuristics->push_back(base::MakeUnique<QuotaService::TimedLimit>(
+  heuristics->push_back(std::make_unique<QuotaService::TimedLimit>(
       short_limit_config, new QuotaLimitHeuristic::SingletonBucketMapper(),
       "MAX_PIN_DIALOGS_CLOSED_PER_10_MINUTES"));
 }
diff --git a/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.cc b/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.cc
index c732c6ef6d0..e256545636c 100644
--- a/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.cc
+++ b/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.cc
@@ -4,11 +4,11 @@
 
 #include "chrome/browser/extensions/api/chrome_extensions_api_client.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/data_use_measurement/data_use_web_contents_observer.h"
@@ -123,13 +123,13 @@ ChromeExtensionsAPIClient::CreateExtensionOptionsGuestDelegate(
 std::unique_ptr<guest_view::GuestViewManagerDelegate>
 ChromeExtensionsAPIClient::CreateGuestViewManagerDelegate(
     content::BrowserContext* context) const {
-  return base::MakeUnique<ChromeGuestViewManagerDelegate>(context);
+  return std::make_unique<ChromeGuestViewManagerDelegate>(context);
 }
 
 std::unique_ptr<MimeHandlerViewGuestDelegate>
 ChromeExtensionsAPIClient::CreateMimeHandlerViewGuestDelegate(
     MimeHandlerViewGuest* guest) const {
-  return base::MakeUnique<ChromeMimeHandlerViewGuestDelegate>();
+  return std::make_unique<ChromeMimeHandlerViewGuestDelegate>();
 }
 
 WebViewGuestDelegate* ChromeExtensionsAPIClient::CreateWebViewGuestDelegate(
@@ -145,7 +145,7 @@ WebViewPermissionHelperDelegate* ChromeExtensionsAPIClient::
 
 std::unique_ptr<WebRequestEventRouterDelegate>
 ChromeExtensionsAPIClient::CreateWebRequestEventRouterDelegate() const {
-  return base::MakeUnique<ChromeExtensionWebRequestEventRouterDelegate>();
+  return std::make_unique<ChromeExtensionWebRequestEventRouterDelegate>();
 }
 
 scoped_refptr<ContentRulesRegistry>
@@ -163,14 +163,14 @@ ChromeExtensionsAPIClient::CreateContentRulesRegistry(
 std::unique_ptr<DevicePermissionsPrompt>
 ChromeExtensionsAPIClient::CreateDevicePermissionsPrompt(
     content::WebContents* web_contents) const {
-  return base::MakeUnique<ChromeDevicePermissionsPrompt>(web_contents);
+  return std::make_unique<ChromeDevicePermissionsPrompt>(web_contents);
 }
 
 std::unique_ptr<VirtualKeyboardDelegate>
 ChromeExtensionsAPIClient::CreateVirtualKeyboardDelegate(
     content::BrowserContext* browser_context) const {
 #if defined(OS_CHROMEOS)
-  return base::MakeUnique<ChromeVirtualKeyboardDelegate>(browser_context);
+  return std::make_unique<ChromeVirtualKeyboardDelegate>(browser_context);
 #else
   return nullptr;
 #endif
@@ -199,13 +199,13 @@ ChromeExtensionsAPIClient::GetNetworkingCastPrivateDelegate() {
 
 FileSystemDelegate* ChromeExtensionsAPIClient::GetFileSystemDelegate() {
   if (!file_system_delegate_)
-    file_system_delegate_ = base::MakeUnique<ChromeFileSystemDelegate>();
+    file_system_delegate_ = std::make_unique<ChromeFileSystemDelegate>();
   return file_system_delegate_.get();
 }
 
 MessagingDelegate* ChromeExtensionsAPIClient::GetMessagingDelegate() {
   if (!messaging_delegate_)
-    messaging_delegate_ = base::MakeUnique<ChromeMessagingDelegate>();
+    messaging_delegate_ = std::make_unique<ChromeMessagingDelegate>();
   return messaging_delegate_.get();
 }
 
@@ -213,7 +213,7 @@ FeedbackPrivateDelegate*
 ChromeExtensionsAPIClient::GetFeedbackPrivateDelegate() {
   if (!feedback_private_delegate_) {
     feedback_private_delegate_ =
-        base::MakeUnique<ChromeFeedbackPrivateDelegate>();
+        std::make_unique<ChromeFeedbackPrivateDelegate>();
   }
   return feedback_private_delegate_.get();
 }
@@ -232,7 +232,7 @@ NonNativeFileSystemDelegate*
 ChromeExtensionsAPIClient::GetNonNativeFileSystemDelegate() {
   if (!non_native_file_system_delegate_) {
     non_native_file_system_delegate_ =
-        base::MakeUnique<NonNativeFileSystemDelegateChromeOS>();
+        std::make_unique<NonNativeFileSystemDelegateChromeOS>();
   }
   return non_native_file_system_delegate_.get();
 }
@@ -244,7 +244,7 @@ void ChromeExtensionsAPIClient::SaveImageDataToClipboard(
     const base::Closure& success_callback,
     const base::Callback<void(const std::string&)>& error_callback) {
   if (!clipboard_extension_helper_)
-    clipboard_extension_helper_ = base::MakeUnique<ClipboardExtensionHelper>();
+    clipboard_extension_helper_ = std::make_unique<ClipboardExtensionHelper>();
   clipboard_extension_helper_->DecodeAndSaveImageData(
       image_data, type, std::move(additional_items), success_callback,
       error_callback);
diff --git a/chromium/chrome/browser/extensions/api/cloud_print_private/cloud_print_private_api.cc b/chromium/chrome/browser/extensions/api/cloud_print_private/cloud_print_private_api.cc
index a1c2baeb69f..90c1889cb5e 100644
--- a/chromium/chrome/browser/extensions/api/cloud_print_private/cloud_print_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/cloud_print_private/cloud_print_private_api.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/extensions/api/cloud_print_private/cloud_print_private_api.h"
 
+#include <memory>
 #include <string>
 
-#include "base/memory/ptr_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
@@ -21,20 +21,20 @@ namespace {
 
 const char kErrorIncognito[] = "Cannot access in incognito mode";
 
-CloudPrintTestsDelegate* g_instance = nullptr;
+CloudPrintTestsDelegate* g_cloud_print_private_api_instance = nullptr;
 
 }  // namespace
 
 CloudPrintTestsDelegate* CloudPrintTestsDelegate::Get() {
-  return g_instance;
+  return g_cloud_print_private_api_instance;
 }
 
 CloudPrintTestsDelegate::CloudPrintTestsDelegate() {
-  g_instance = this;
+  g_cloud_print_private_api_instance = this;
 }
 
 CloudPrintTestsDelegate::~CloudPrintTestsDelegate() {
-  g_instance = nullptr;
+  g_cloud_print_private_api_instance = nullptr;
 }
 
 CloudPrintPrivateSetupConnectorFunction::
@@ -77,7 +77,7 @@ CloudPrintPrivateGetHostNameFunction::~CloudPrintPrivateGetHostNameFunction() {
 }
 
 bool CloudPrintPrivateGetHostNameFunction::RunAsync() {
-  SetResult(base::MakeUnique<base::Value>(
+  SetResult(std::make_unique<base::Value>(
       CloudPrintTestsDelegate::Get()
           ? CloudPrintTestsDelegate::Get()->GetHostName()
           : net::GetHostName()));
@@ -122,7 +122,7 @@ CloudPrintPrivateGetClientIdFunction::~CloudPrintPrivateGetClientIdFunction() {
 }
 
 bool CloudPrintPrivateGetClientIdFunction::RunAsync() {
-  SetResult(base::MakeUnique<base::Value>(
+  SetResult(std::make_unique<base::Value>(
       CloudPrintTestsDelegate::Get()
           ? CloudPrintTestsDelegate::Get()->GetClientId()
           : google_apis::GetOAuth2ClientID(google_apis::CLIENT_CLOUD_PRINT)));
diff --git a/chromium/chrome/browser/extensions/api/commands/command_service.cc b/chromium/chrome/browser/extensions/api/commands/command_service.cc
index f59d3898b3e..3f3661f362e 100644
--- a/chromium/chrome/browser/extensions/api/commands/command_service.cc
+++ b/chromium/chrome/browser/extensions/api/commands/command_service.cc
@@ -4,11 +4,11 @@
 
 #include "chrome/browser/extensions/api/commands/command_service.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -87,7 +87,7 @@ std::string StripCurrentPlatform(const std::string& key) {
 void SetInitialBindingsHaveBeenAssigned(
     ExtensionPrefs* prefs, const std::string& extension_id) {
   prefs->UpdateExtensionPref(extension_id, kInitialBindingsHaveBeenAssigned,
-                             base::MakeUnique<base::Value>(true));
+                             std::make_unique<base::Value>(true));
 }
 
 bool InitialBindingsHaveBeenAssigned(
@@ -277,7 +277,7 @@ bool CommandService::AddKeybindingPref(
     RemoveKeybindingPrefs(extension_id, command_name);
 
   // Set the keybinding pref.
-  auto keybinding = base::MakeUnique<base::DictionaryValue>();
+  auto keybinding = std::make_unique<base::DictionaryValue>();
   keybinding->SetString(kExtension, extension_id);
   keybinding->SetString(kCommandName, command_name);
   keybinding->SetBoolean(kGlobal, global);
diff --git a/chromium/chrome/browser/extensions/api/commands/command_service_browsertest.cc b/chromium/chrome/browser/extensions/api/commands/command_service_browsertest.cc
index efdef908686..c9ecdae11e3 100644
--- a/chromium/chrome/browser/extensions/api/commands/command_service_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/commands/command_service_browsertest.cc
@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ -116,7 +116,7 @@ IN_PROC_BROWSER_TEST_F(CommandServiceTest,
   // another platform.
   std::string anotherPlatformKey = GetAnotherCommandPlatform() + ":Alt+G";
   const char kNamedCommandName[] = "toggle-feature";
-  auto keybinding = base::MakeUnique<base::DictionaryValue>();
+  auto keybinding = std::make_unique<base::DictionaryValue>();
   keybinding->SetString("extension", extension->id());
   keybinding->SetString("command_name", kNamedCommandName);
   keybinding->SetBoolean("global", false);
diff --git a/chromium/chrome/browser/extensions/api/content_settings/content_settings_store.cc b/chromium/chrome/browser/extensions/api/content_settings/content_settings_store.cc
index dd3ce91a420..d3574455ee9 100644
--- a/chromium/chrome/browser/extensions/api/content_settings/content_settings_store.cc
+++ b/chromium/chrome/browser/extensions/api/content_settings/content_settings_store.cc
@@ -91,7 +91,7 @@ std::unique_ptr<RuleIterator> ContentSettingsStore::GetRuleIterator(
   if (iterators.empty())
     return nullptr;
 
-  return base::MakeUnique<ConcatenationIterator>(std::move(iterators),
+  return std::make_unique<ConcatenationIterator>(std::move(iterators),
                                                  auto_lock.release());
 }
 
@@ -254,7 +254,7 @@ std::unique_ptr<base::ListValue> ContentSettingsStore::GetSettingsForExtension(
   if (!map)
     return nullptr;
 
-  auto settings = base::MakeUnique<base::ListValue>();
+  auto settings = std::make_unique<base::ListValue>();
   for (const auto& it : *map) {
     const auto& key = it.first;
     std::unique_ptr<RuleIterator> rule_iterator(
diff --git a/chromium/chrome/browser/extensions/api/content_settings/content_settings_store_unittest.cc b/chromium/chrome/browser/extensions/api/content_settings/content_settings_store_unittest.cc
index f516ce449e9..7a951d797d3 100644
--- a/chromium/chrome/browser/extensions/api/content_settings/content_settings_store_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/content_settings/content_settings_store_unittest.cc
@@ -8,7 +8,6 @@
 
 #include <memory>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_api_constants.h"
 #include "components/content_settings/core/browser/content_settings_registry.h"
@@ -293,7 +292,7 @@ TEST_F(ContentSettingsStoreTest, SetFromList) {
   base::ListValue pref_list;
   // {"primaryPattern": pattern, "secondaryPattern": pattern, "type": "cookies",
   //  "setting": "allow"}
-  auto dict_value = base::MakeUnique<base::DictionaryValue>();
+  auto dict_value = std::make_unique<base::DictionaryValue>();
   dict_value->SetString(keys::kPrimaryPatternKey, pattern.ToString());
   dict_value->SetString(keys::kSecondaryPatternKey, pattern.ToString());
   dict_value->SetString(keys::kContentSettingsTypeKey, "cookies");
@@ -302,7 +301,7 @@ TEST_F(ContentSettingsStoreTest, SetFromList) {
   // Test content settings types that have been removed. Should be ignored.
   // {"primaryPattern": pattern, "secondaryPattern": pattern,
   //  "type": "fullscreen", "setting": "allow"}
-  dict_value = base::MakeUnique<base::DictionaryValue>();
+  dict_value = std::make_unique<base::DictionaryValue>();
   dict_value->SetString(keys::kPrimaryPatternKey, pattern.ToString());
   dict_value->SetString(keys::kSecondaryPatternKey, pattern.ToString());
   dict_value->SetString(keys::kContentSettingsTypeKey, "fullscreen");
@@ -310,7 +309,7 @@ TEST_F(ContentSettingsStoreTest, SetFromList) {
   pref_list.Append(std::move(dict_value));
   // {"primaryPattern": pattern, "secondaryPattern": pattern,
   //  "type": "mouselock", "setting": "allow"}
-  dict_value = base::MakeUnique<base::DictionaryValue>();
+  dict_value = std::make_unique<base::DictionaryValue>();
   dict_value->SetString(keys::kPrimaryPatternKey, pattern.ToString());
   dict_value->SetString(keys::kSecondaryPatternKey, pattern.ToString());
   dict_value->SetString(keys::kContentSettingsTypeKey, "mouselock");
diff --git a/chromium/chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h b/chromium/chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h
index 9b63355c2ed..7dc82e0fd1a 100644
--- a/chromium/chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h
+++ b/chromium/chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h
@@ -211,11 +211,16 @@ bool UpdateMenuItem(const PropertyWithEnumT& update_properties,
       *error = kCheckedError;
       return false;
     }
-    // If the item was not checked and it is updated to be checked, set it to be
-    // checked. If the radio item was unchecked, nothing should happen. The
-    // radio item should remain checked because there should always be one item
-    // checked in the radio list.
-    if (checked && !item->checked()) {
+
+    const bool should_toggle_checked =
+        // If radio item was unchecked nothing should happen. The radio item
+        // should remain checked because there should always be one item checked
+        // in the radio list.
+        (item->type() == MenuItem::RADIO && checked) ||
+        // Checkboxes are always updated.
+        item->type() == MenuItem::CHECKBOX;
+
+    if (should_toggle_checked) {
       if (!item->SetChecked(checked)) {
         *error = kCheckedError;
         return false;
diff --git a/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc b/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc
index 1b0604b446b..f77080331df 100644
--- a/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc
+++ b/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc
@@ -13,7 +13,6 @@
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -24,18 +23,17 @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/extensions/api/cookies.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/storage_partition.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_constants.h"
-#include "net/cookies/cookie_monster.h"
-#include "net/cookies/cookie_store.h"
-#include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "services/network/public/interfaces/network_service.mojom.h"
 
 using content::BrowserThread;
 
@@ -71,10 +69,9 @@ bool ParseUrl(ChromeAsyncExtensionFunction* function,
   return true;
 }
 
-bool ParseStoreContext(ChromeAsyncExtensionFunction* function,
-                       std::string* store_id,
-                       net::URLRequestContextGetter** context) {
-  DCHECK((context || store_id->empty()));
+network::mojom::CookieManager* ParseStoreCookieManager(
+    ChromeAsyncExtensionFunction* function,
+    std::string* store_id) {
   Profile* store_profile = NULL;
   if (!store_id->empty()) {
     store_profile = cookies_helpers::ChooseProfileFromStoreId(
@@ -82,26 +79,25 @@ bool ParseStoreContext(ChromeAsyncExtensionFunction* function,
     if (!store_profile) {
       function->SetError(ErrorUtils::FormatErrorMessage(
           keys::kInvalidStoreIdError, *store_id));
-      return false;
+      return nullptr;
     }
   } else {
     // The store ID was not specified; use the current execution context's
     // cookie store by default.
     // GetCurrentBrowser() already takes into account incognito settings.
+    // TODO(rdevlin.cronin): Relying on the current execution context is
+    // almost never the right answer; clean this up.
     Browser* current_browser = function->GetCurrentBrowser();
     if (!current_browser) {
       function->SetError(keys::kNoCookieStoreFoundError);
-      return false;
+      return nullptr;
     }
     store_profile = current_browser->profile();
     *store_id = cookies_helpers::GetStoreIdFromProfile(store_profile);
   }
 
-  if (context)
-    *context = store_profile->GetRequestContext();
-  DCHECK(context);
-
-  return true;
+  return content::BrowserContext::GetDefaultStoragePartition(store_profile)
+      ->GetCookieManagerForBrowserProcess();
 }
 
 }  // namespace
@@ -146,32 +142,28 @@ void CookiesEventRouter::CookieChanged(
   switch (details->cause) {
     // Report an inserted cookie as an "explicit" change cause. All other causes
     // only make sense for deletions.
-    case net::CookieStore::ChangeCause::INSERTED:
-    case net::CookieStore::ChangeCause::EXPLICIT:
-    case net::CookieStore::ChangeCause::EXPLICIT_DELETE_BETWEEN:
-    case net::CookieStore::ChangeCause::EXPLICIT_DELETE_PREDICATE:
-    case net::CookieStore::ChangeCause::EXPLICIT_DELETE_SINGLE:
-    case net::CookieStore::ChangeCause::EXPLICIT_DELETE_CANONICAL:
+    case network::mojom::CookieChangeCause::INSERTED:
+    case network::mojom::CookieChangeCause::EXPLICIT:
       cause = keys::kExplicitChangeCause;
       break;
 
-    case net::CookieStore::ChangeCause::OVERWRITE:
+    case network::mojom::CookieChangeCause::OVERWRITE:
       cause = keys::kOverwriteChangeCause;
       break;
 
-    case net::CookieStore::ChangeCause::EXPIRED:
+    case network::mojom::CookieChangeCause::EXPIRED:
       cause = keys::kExpiredChangeCause;
       break;
 
-    case net::CookieStore::ChangeCause::EVICTED:
+    case network::mojom::CookieChangeCause::EVICTED:
       cause = keys::kEvictedChangeCause;
       break;
 
-    case net::CookieStore::ChangeCause::EXPIRED_OVERWRITE:
+    case network::mojom::CookieChangeCause::EXPIRED_OVERWRITE:
       cause = keys::kExpiredOverwriteChangeCause;
       break;
 
-    case net::CookieStore::ChangeCause::UNKNOWN_DELETION:
+    case network::mojom::CookieChangeCause::UNKNOWN_DELETION:
       NOTREACHED();
   }
   dict->SetString(keys::kCauseKey, cause);
@@ -193,7 +185,7 @@ void CookiesEventRouter::DispatchEvent(
   EventRouter* router = context ? EventRouter::Get(context) : NULL;
   if (!router)
     return;
-  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+  auto event = std::make_unique<Event>(histogram_value, event_name,
                                        std::move(event_args), context);
   event->event_url = cookie_domain;
   router->BroadcastEvent(std::move(event));
@@ -216,38 +208,28 @@ bool CookiesGetFunction::RunAsync() {
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
-  net::URLRequestContextGetter* store_context = NULL;
-  if (!ParseStoreContext(this, &store_id, &store_context))
+  network::mojom::CookieManager* cookie_manager =
+      ParseStoreCookieManager(this, &store_id);
+  if (!cookie_manager)
     return false;
-  store_browser_context_ = store_context;
+
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
-  store_browser_context_ = store_context;
-
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&CookiesGetFunction::GetCookieOnIOThread, this));
-  DCHECK(rv);
+  cookies_helpers::GetCookieListFromManager(
+      cookie_manager, url_,
+      base::BindOnce(&CookiesGetFunction::GetCookieCallback, this));
 
   // Will finish asynchronously.
   return true;
 }
 
-void CookiesGetFunction::GetCookieOnIOThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  net::CookieStore* cookie_store =
-      store_browser_context_->GetURLRequestContext()->cookie_store();
-  cookies_helpers::GetCookieListFromStore(
-      cookie_store, url_,
-      base::BindOnce(&CookiesGetFunction::GetCookieCallback, this));
-}
-
 void CookiesGetFunction::GetCookieCallback(const net::CookieList& cookie_list) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (const net::CanonicalCookie& cookie : cookie_list) {
     // Return the first matching cookie. Relies on the fact that the
-    // CookieMonster returns them in canonical order (longest path, then
-    // earliest creation time).
+    // CookieManager interface returns them in canonical order (longest path,
+    // then earliest creation time).
     if (cookie.Name() == parsed_args_->details.name) {
       cookies::Cookie api_cookie = cookies_helpers::CreateCookie(
           cookie, *parsed_args_->details.store_id);
@@ -258,16 +240,8 @@ void CookiesGetFunction::GetCookieCallback(const net::CookieList& cookie_list) {
 
   // The cookie doesn't exist; return null.
   if (!results_)
-    SetResult(base::MakeUnique<base::Value>());
+    SetResult(std::make_unique<base::Value>());
 
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&CookiesGetFunction::RespondOnUIThread, this));
-  DCHECK(rv);
-}
-
-void CookiesGetFunction::RespondOnUIThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
@@ -289,33 +263,26 @@ bool CookiesGetAllFunction::RunAsync() {
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
-  net::URLRequestContextGetter* store_context = NULL;
-  if (!ParseStoreContext(this, &store_id, &store_context))
+  network::mojom::CookieManager* cookie_manager =
+      ParseStoreCookieManager(this, &store_id);
+  if (!cookie_manager)
     return false;
-  store_browser_context_ = store_context;
+
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&CookiesGetAllFunction::GetAllCookiesOnIOThread, this));
-  DCHECK(rv);
+  DCHECK(url_.is_empty() || url_.is_valid());
+  cookies_helpers::GetCookieListFromManager(
+      cookie_manager, url_,
+      base::BindOnce(&CookiesGetAllFunction::GetAllCookiesCallback, this));
 
   // Will finish asynchronously.
   return true;
 }
 
-void CookiesGetAllFunction::GetAllCookiesOnIOThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  net::CookieStore* cookie_store =
-      store_browser_context_->GetURLRequestContext()->cookie_store();
-  cookies_helpers::GetCookieListFromStore(
-      cookie_store, url_,
-      base::BindOnce(&CookiesGetAllFunction::GetAllCookiesCallback, this));
-}
-
 void CookiesGetAllFunction::GetAllCookiesCallback(
     const net::CookieList& cookie_list) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (extension()) {
     std::vector<cookies::Cookie> match_vector;
     cookies_helpers::AppendMatchingCookiesToVector(
@@ -323,19 +290,11 @@ void CookiesGetAllFunction::GetAllCookiesCallback(
 
     results_ = GetAll::Results::Create(match_vector);
   }
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&CookiesGetAllFunction::RespondOnUIThread, this));
-  DCHECK(rv);
-}
-
-void CookiesGetAllFunction::RespondOnUIThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
-CookiesSetFunction::CookiesSetFunction() : success_(false) {
-}
+CookiesSetFunction::CookiesSetFunction()
+    : state_(NO_RESPONSE), success_(false) {}
 
 CookiesSetFunction::~CookiesSetFunction() {
 }
@@ -351,26 +310,14 @@ bool CookiesSetFunction::RunAsync() {
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
-  net::URLRequestContextGetter* store_context = NULL;
-  if (!ParseStoreContext(this, &store_id, &store_context))
+  network::mojom::CookieManager* cookie_manager =
+      ParseStoreCookieManager(this, &store_id);
+  if (!cookie_manager)
     return false;
-  store_browser_context_ = store_context;
+
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&CookiesSetFunction::SetCookieOnIOThread, this));
-  DCHECK(rv);
-
-  // Will finish asynchronously.
-  return true;
-}
-
-void CookiesSetFunction::SetCookieOnIOThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  net::CookieStore* cookie_store =
-      store_browser_context_->GetURLRequestContext()->cookie_store();
 
   base::Time expiration_time;
   if (parsed_args_->details.expiration_date.get()) {
@@ -418,26 +365,40 @@ void CookiesSetFunction::SetCookieOnIOThread() {
           net::COOKIE_PRIORITY_DEFAULT));
   // clang-format on
   if (!cc) {
-    PullCookie(false);
-    return;
+    // Return error through callbacks so that the proper error message
+    // is generated.
+    success_ = false;
+    state_ = SET_COMPLETED;
+    GetCookieListCallback(net::CookieList());
+    return true;
   }
-  cookie_store->SetCanonicalCookieAsync(
-      std::move(cc), url_.SchemeIsCryptographic(), true /*modify_http_only*/,
-      base::BindOnce(&CookiesSetFunction::PullCookie, this));
+
+  // Dispatch the setter, immediately followed by the getter.  This
+  // plus FIFO ordering on the cookie_manager_ pipe means that no
+  // other extension function will affect the get result.
+  cookie_manager->SetCanonicalCookie(
+      *cc, url_.SchemeIsCryptographic(), true /*modify_http_only*/,
+      base::BindOnce(&CookiesSetFunction::SetCanonicalCookieCallback, this));
+  cookies_helpers::GetCookieListFromManager(
+      cookie_manager, url_,
+      base::BindOnce(&CookiesSetFunction::GetCookieListCallback, this));
+
+  // Will finish asynchronously.
+  return true;
 }
 
-void CookiesSetFunction::PullCookie(bool set_cookie_result) {
-  // Pull the newly set cookie.
-  net::CookieStore* cookie_store =
-      store_browser_context_->GetURLRequestContext()->cookie_store();
+void CookiesSetFunction::SetCanonicalCookieCallback(bool set_cookie_result) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_EQ(NO_RESPONSE, state_);
+  state_ = SET_COMPLETED;
   success_ = set_cookie_result;
-  cookies_helpers::GetCookieListFromStore(
-      cookie_store, url_,
-      base::BindOnce(&CookiesSetFunction::PullCookieCallback, this));
 }
 
-void CookiesSetFunction::PullCookieCallback(
+void CookiesSetFunction::GetCookieListCallback(
     const net::CookieList& cookie_list) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_EQ(SET_COMPLETED, state_);
+  state_ = GET_COMPLETED;
   for (const net::CanonicalCookie& cookie : cookie_list) {
     // Return the first matching cookie. Relies on the fact that the
     // CookieMonster returns them in canonical order (longest path, then
@@ -453,18 +414,12 @@ void CookiesSetFunction::PullCookieCallback(
     }
   }
 
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&CookiesSetFunction::RespondOnUIThread, this));
-  DCHECK(rv);
-}
-
-void CookiesSetFunction::RespondOnUIThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!success_) {
     std::string name =
         parsed_args_->details.name.get() ? *parsed_args_->details.name
                                          : std::string();
+    // TODO(rdevlin.cronin): Avoid setting both error_ and results_ in the
+    // same call.
     error_ = ErrorUtils::FormatErrorMessage(keys::kCookieSetFailedError, name);
   }
   SendResponse(success_);
@@ -487,35 +442,29 @@ bool CookiesRemoveFunction::RunAsync() {
   std::string store_id =
       parsed_args_->details.store_id.get() ? *parsed_args_->details.store_id
                                            : std::string();
-  net::URLRequestContextGetter* store_context = NULL;
-  if (!ParseStoreContext(this, &store_id, &store_context))
+  network::mojom::CookieManager* cookie_manager =
+      ParseStoreCookieManager(this, &store_id);
+  if (!cookie_manager)
     return false;
-  store_browser_context_ = store_context;
+
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
-  // Pass the work off to the IO thread.
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::BindOnce(&CookiesRemoveFunction::RemoveCookieOnIOThread, this));
-  DCHECK(rv);
+  network::mojom::CookieDeletionFilterPtr filter(
+      network::mojom::CookieDeletionFilter::New());
+  filter->url = url_;
+  filter->cookie_name = parsed_args_->details.name;
+  cookie_manager->DeleteCookies(
+      std::move(filter),
+      base::BindOnce(&CookiesRemoveFunction::RemoveCookieCallback, this));
 
   // Will return asynchronously.
   return true;
 }
 
-void CookiesRemoveFunction::RemoveCookieOnIOThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  // Remove the cookie
-  net::CookieStore* cookie_store =
-      store_browser_context_->GetURLRequestContext()->cookie_store();
-  cookie_store->DeleteCookieAsync(
-      url_, parsed_args_->details.name,
-      base::BindOnce(&CookiesRemoveFunction::RemoveCookieCallback, this));
-}
+void CookiesRemoveFunction::RemoveCookieCallback(uint32_t /* num_deleted */) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-void CookiesRemoveFunction::RemoveCookieCallback() {
   // Build the callback result
   Remove::Results::Details details;
   details.name = parsed_args_->details.name;
@@ -523,15 +472,6 @@ void CookiesRemoveFunction::RemoveCookieCallback() {
   details.store_id = *parsed_args_->details.store_id;
   results_ = Remove::Results::Create(details);
 
-  // Return to UI thread
-  bool rv = BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::BindOnce(&CookiesRemoveFunction::RespondOnUIThread, this));
-  DCHECK(rv);
-}
-
-void CookiesRemoveFunction::RespondOnUIThread() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SendResponse(true);
 }
 
diff --git a/chromium/chrome/browser/extensions/api/cookies/cookies_api.h b/chromium/chrome/browser/extensions/api/cookies/cookies_api.h
index 4dfa71cc76c..b5a5ad044f1 100644
--- a/chromium/chrome/browser/extensions/api/cookies/cookies_api.h
+++ b/chromium/chrome/browser/extensions/api/cookies/cookies_api.h
@@ -22,12 +22,9 @@
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
 #include "net/cookies/canonical_cookie.h"
+#include "services/network/public/interfaces/cookie_manager.mojom.h"
 #include "url/gurl.h"
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace extensions {
 
 // Observes CookieMonster notifications and routes them as events to the
@@ -76,12 +73,10 @@ class CookiesGetFunction : public ChromeAsyncExtensionFunction {
   bool RunAsync() override;
 
  private:
-  void GetCookieOnIOThread();
-  void RespondOnUIThread();
   void GetCookieCallback(const net::CookieList& cookie_list);
 
   GURL url_;
-  scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
+  network::mojom::CookieManagerPtr store_browser_cookie_manager_;
   std::unique_ptr<api::cookies::Get::Params> parsed_args_;
 };
 
@@ -99,12 +94,10 @@ class CookiesGetAllFunction : public ChromeAsyncExtensionFunction {
   bool RunAsync() override;
 
  private:
-  void GetAllCookiesOnIOThread();
-  void RespondOnUIThread();
   void GetAllCookiesCallback(const net::CookieList& cookie_list);
 
   GURL url_;
-  scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
+  network::mojom::CookieManagerPtr store_browser_cookie_manager_;
   std::unique_ptr<api::cookies::GetAll::Params> parsed_args_;
 };
 
@@ -120,14 +113,13 @@ class CookiesSetFunction : public ChromeAsyncExtensionFunction {
   bool RunAsync() override;
 
  private:
-  void SetCookieOnIOThread();
-  void RespondOnUIThread();
-  void PullCookie(bool set_cookie_);
-  void PullCookieCallback(const net::CookieList& cookie_list);
+  void SetCanonicalCookieCallback(bool set_cookie_);
+  void GetCookieListCallback(const net::CookieList& cookie_list);
 
+  enum { NO_RESPONSE, SET_COMPLETED, GET_COMPLETED } state_;
   GURL url_;
   bool success_;
-  scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
+  network::mojom::CookieManagerPtr store_browser_cookie_manager_;
   std::unique_ptr<api::cookies::Set::Params> parsed_args_;
 };
 
@@ -145,12 +137,10 @@ class CookiesRemoveFunction : public ChromeAsyncExtensionFunction {
   bool RunAsync() override;
 
  private:
-  void RemoveCookieOnIOThread();
-  void RespondOnUIThread();
-  void RemoveCookieCallback();
+  void RemoveCookieCallback(uint32_t /* num_deleted */);
 
   GURL url_;
-  scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
+  network::mojom::CookieManagerPtr store_browser_cookie_manager_;
   std::unique_ptr<api::cookies::Remove::Params> parsed_args_;
 };
 
diff --git a/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.cc b/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.cc
index 42ca67b2839..a9b8840e4d9 100644
--- a/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.cc
@@ -118,16 +118,20 @@ CookieStore CreateCookieStore(Profile* profile,
   return cookie_store;
 }
 
-void GetCookieListFromStore(
-    net::CookieStore* cookie_store,
+void GetCookieListFromManager(
+    network::mojom::CookieManager* manager,
     const GURL& url,
-    net::CookieMonster::GetCookieListCallback callback) {
-  DCHECK(cookie_store);
-  if (!url.is_empty()) {
-    DCHECK(url.is_valid());
-    cookie_store->GetAllCookiesForURLAsync(url, std::move(callback));
+    network::mojom::CookieManager::GetCookieListCallback callback) {
+  if (url.is_empty()) {
+    manager->GetAllCookies(std::move(callback));
   } else {
-    cookie_store->GetAllCookiesAsync(std::move(callback));
+    net::CookieOptions options;
+    options.set_include_httponly();
+    options.set_same_site_cookie_mode(
+        net::CookieOptions::SameSiteCookieMode::INCLUDE_STRICT_AND_LAX);
+    options.set_do_not_update_access_time();
+
+    manager->GetCookieList(url, options, std::move(callback));
   }
 }
 
diff --git a/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.h b/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.h
index 0fa58c69046..ec287ffbce9 100644
--- a/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.h
+++ b/chromium/chrome/browser/extensions/api/cookies/cookies_helpers.h
@@ -15,8 +15,10 @@
 #include <vector>
 
 #include "chrome/common/extensions/api/cookies.h"
-#include "net/cookies/cookie_monster.h"
 #include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_monster.h"
+#include "net/cookies/cookie_options.h"
+#include "services/network/public/interfaces/cookie_manager.mojom.h"
 
 class Browser;
 class Profile;
@@ -55,12 +57,12 @@ api::cookies::CookieStore CreateCookieStore(
     Profile* profile,
     std::unique_ptr<base::ListValue> tab_ids);
 
-// Retrieves all cookies from the given cookie store corresponding to the given
-// URL. If the URL is empty, all cookies in the cookie store are retrieved.
-// This can only be called on the IO thread.
-void GetCookieListFromStore(net::CookieStore* cookie_store,
-                            const GURL& url,
-                            net::CookieMonster::GetCookieListCallback callback);
+// Dispatch a request to the CookieManager for cookies associated with
+// |url|, or all cookies if |url.is_empty()|.
+void GetCookieListFromManager(
+    network::mojom::CookieManager* manager,
+    const GURL& url,
+    network::mojom::CookieManager::GetCookieListCallback callback);
 
 // Constructs a URL from a cookie's information for use in checking
 // a cookie against the extension's host permissions. The Secure
diff --git a/chromium/chrome/browser/extensions/api/cookies/cookies_unittest.cc b/chromium/chrome/browser/extensions/api/cookies/cookies_unittest.cc
index 6aeccbf2a6c..ce043bf958c 100644
--- a/chromium/chrome/browser/extensions/api/cookies/cookies_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/cookies/cookies_unittest.cc
@@ -7,10 +7,10 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/cookies/cookies_api_constants.h"
 #include "chrome/browser/extensions/api/cookies/cookies_helpers.h"
@@ -86,7 +86,7 @@ TEST_F(ExtensionCookiesTest, StoreIdProfileConversion) {
 
 TEST_F(ExtensionCookiesTest, ExtensionTypeCreation) {
   std::unique_ptr<net::CanonicalCookie> canonical_cookie1(
-      base::MakeUnique<net::CanonicalCookie>(
+      std::make_unique<net::CanonicalCookie>(
           "ABC", "DEF", "www.example.com", "/", base::Time(), base::Time(),
           base::Time(), false, false, net::CookieSameSite::DEFAULT_MODE,
           net::COOKIE_PRIORITY_DEFAULT));
@@ -106,7 +106,7 @@ TEST_F(ExtensionCookiesTest, ExtensionTypeCreation) {
   EXPECT_EQ("some cookie store", cookie1.store_id);
 
   std::unique_ptr<net::CanonicalCookie> canonical_cookie2(
-      base::MakeUnique<net::CanonicalCookie>(
+      std::make_unique<net::CanonicalCookie>(
           "ABC", "DEF", ".example.com", "/", base::Time(),
           base::Time::FromDoubleT(10000), base::Time(), false, false,
           net::CookieSameSite::STRICT_MODE, net::COOKIE_PRIORITY_DEFAULT));
@@ -120,7 +120,7 @@ TEST_F(ExtensionCookiesTest, ExtensionTypeCreation) {
   EXPECT_EQ(10000, *cookie2.expiration_date);
 
   TestingProfile profile;
-  auto tab_ids_list = base::MakeUnique<base::ListValue>();
+  auto tab_ids_list = std::make_unique<base::ListValue>();
   std::vector<int> tab_ids;
   CookieStore cookie_store =
       cookies_helpers::CreateCookieStore(&profile, std::move(tab_ids_list));
@@ -130,7 +130,7 @@ TEST_F(ExtensionCookiesTest, ExtensionTypeCreation) {
 
 TEST_F(ExtensionCookiesTest, GetURLFromCanonicalCookie) {
   std::unique_ptr<net::CanonicalCookie> cookie1(
-      base::MakeUnique<net::CanonicalCookie>(
+      std::make_unique<net::CanonicalCookie>(
           "ABC", "DEF", ".example.com", "/", base::Time(), base::Time(),
           base::Time(), false, false, net::CookieSameSite::DEFAULT_MODE,
           net::COOKIE_PRIORITY_DEFAULT));
@@ -139,7 +139,7 @@ TEST_F(ExtensionCookiesTest, GetURLFromCanonicalCookie) {
             cookies_helpers::GetURLFromCanonicalCookie(*cookie1).spec());
 
   std::unique_ptr<net::CanonicalCookie> cookie2(
-      base::MakeUnique<net::CanonicalCookie>(
+      std::make_unique<net::CanonicalCookie>(
           "ABC", "DEF", ".helloworld.com", "/", base::Time(), base::Time(),
           base::Time(), true, false, net::CookieSameSite::DEFAULT_MODE,
           net::COOKIE_PRIORITY_DEFAULT));
@@ -168,14 +168,14 @@ TEST_F(ExtensionCookiesTest, DomainMatching) {
   for (size_t i = 0; i < arraysize(tests); ++i) {
     // Build up the Params struct.
     base::ListValue args;
-    auto dict = base::MakeUnique<base::DictionaryValue>();
+    auto dict = std::make_unique<base::DictionaryValue>();
     dict->SetString(keys::kDomainKey, std::string(tests[i].filter));
     args.Set(0, std::move(dict));
     std::unique_ptr<GetAll::Params> params(GetAll::Params::Create(args));
 
     cookies_helpers::MatchFilter filter(&params->details);
     std::unique_ptr<net::CanonicalCookie> cookie(
-        base::MakeUnique<net::CanonicalCookie>(
+        std::make_unique<net::CanonicalCookie>(
             "name", std::string(), tests[i].domain, "/", base::Time(),
             base::Time(), base::Time(), false, false,
             net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
diff --git a/chromium/chrome/browser/extensions/api/cryptotoken_private/OWNERS b/chromium/chrome/browser/extensions/api/cryptotoken_private/OWNERS
index b79c1b519a9..0a8ba68b920 100644
--- a/chromium/chrome/browser/extensions/api/cryptotoken_private/OWNERS
+++ b/chromium/chrome/browser/extensions/api/cryptotoken_private/OWNERS
@@ -1,3 +1,5 @@
 agl@chromium.org
+mab@chromium.org
 kpaulhamus@chromium.org
 arnarb@chromium.org
+juanlang@chromium.org
diff --git a/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.cc b/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.cc
index cbccab463b7..6e99d232a39 100644
--- a/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.cc
@@ -6,11 +6,24 @@
 
 #include <stddef.h>
 
+#include "base/callback.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+#include "chrome/app/vector_icons/vector_icons.h"
+#include "chrome/browser/extensions/extension_tab_util.h"
+#include "chrome/browser/permissions/permission_request.h"
+#include "chrome/browser/permissions/permission_request_manager.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/grit/generated_resources.h"
 #include "components/pref_registry/pref_registry_syncable.h"
+#include "components/prefs/pref_service.h"
+#include "crypto/sha2.h"
 #include "extensions/common/error_utils.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
@@ -19,9 +32,81 @@ constexpr const char* kGoogleGstaticAppIds[] = {
     "https://www.gstatic.com/securitykey/origins.json",
     "https://www.gstatic.com/securitykey/a/google.com/origins.json"};
 
+// ContainsAppIdByHash returns true iff the SHA-256 hash of one of the
+// elements of |list| equals |hash|.
+bool ContainsAppIdByHash(const base::ListValue& list,
+                         const std::vector<char>& hash) {
+  if (hash.size() != crypto::kSHA256Length) {
+    return false;
+  }
+
+  for (const auto& i : list) {
+    const std::string& s = i.GetString();
+    if (s.find('/') == std::string::npos) {
+      // No slashes mean that this is a webauthn RP ID, not a U2F AppID.
+      continue;
+    }
+
+    if (crypto::SHA256HashString(s).compare(0, crypto::kSHA256Length,
+                                            hash.data(),
+                                            crypto::kSHA256Length) == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// AttestationPermissionRequest is a delegate class that provides information
+// and callbacks to the PermissionRequestManager.
+//
+// PermissionRequestManager has a reference to this object and so this object
+// must outlive it. Since attestation requests are never canceled,
+// PermissionRequestManager guarentees that |RequestFinished| will always,
+// eventually, be called. This object uses that fact to delete itself during
+// |RequestFinished| and thus owns itself.
+class AttestationPermissionRequest : public PermissionRequest {
+ public:
+  AttestationPermissionRequest(const GURL& app_id,
+                               base::OnceCallback<void(bool)> callback)
+      : app_id_(app_id), callback_(std::move(callback)) {}
+
+  PermissionRequest::IconId GetIconId() const override {
+    return kUsbSecurityKeyIcon;
+  }
+
+  base::string16 GetMessageTextFragment() const override {
+    return l10n_util::GetStringUTF16(
+        IDS_SECURITY_KEY_ATTESTATION_PERMISSION_FRAGMENT);
+  }
+  GURL GetOrigin() const override { return app_id_; }
+  void PermissionGranted() override { std::move(callback_).Run(true); }
+  void PermissionDenied() override { std::move(callback_).Run(false); }
+  void Cancelled() override { std::move(callback_).Run(false); }
+
+  void RequestFinished() override {
+    if (callback_)
+      std::move(callback_).Run(false);
+    delete this;
+  }
+
+  PermissionRequestType GetPermissionRequestType() const override {
+    return PermissionRequestType::PERMISSION_SECURITY_KEY_ATTESTATION;
+  }
+
+ private:
+  ~AttestationPermissionRequest() override = default;
+
+  const GURL app_id_;
+  base::OnceCallback<void(bool)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(AttestationPermissionRequest);
+};
+
 }  // namespace
 
 namespace extensions {
+
 namespace api {
 
 void CryptotokenRegisterProfilePrefs(
@@ -30,9 +115,7 @@ void CryptotokenRegisterProfilePrefs(
 }
 
 CryptotokenPrivateCanOriginAssertAppIdFunction::
-    CryptotokenPrivateCanOriginAssertAppIdFunction()
-    : chrome_details_(this) {
-}
+    CryptotokenPrivateCanOriginAssertAppIdFunction() = default;
 
 ExtensionFunction::ResponseAction
 CryptotokenPrivateCanOriginAssertAppIdFunction::Run() {
@@ -52,7 +135,7 @@ CryptotokenPrivateCanOriginAssertAppIdFunction::Run() {
   }
 
   if (origin_url == app_id_url) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+    return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
   }
 
   // Fetch the eTLD+1 of both.
@@ -73,7 +156,7 @@ CryptotokenPrivateCanOriginAssertAppIdFunction::Run() {
         "Could not find an eTLD for appId *", params->app_id_url)));
   }
   if (origin_etldp1 == app_id_etldp1) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+    return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
   }
   // For legacy purposes, allow google.com origins to assert certain
   // gstatic.com appIds.
@@ -81,30 +164,93 @@ CryptotokenPrivateCanOriginAssertAppIdFunction::Run() {
   if (origin_etldp1 == kGoogleDotCom) {
     for (const char* id : kGoogleGstaticAppIds) {
       if (params->app_id_url == id)
-        return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+        return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
     }
   }
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(false)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
 }
 
-// TODO(agl/mab): remove special casing for individual attestation in
-// Javascript in favour of an enterprise policy, which can be accessed like
-// this:
-//
-// #include "chrome/browser/profiles/profile.h"
-// #include "components/prefs/pref_service.h"
-//
-//   Profile* const profile = Profile::FromBrowserContext(browser_context());
-//   const PrefService* const prefs = profile->GetPrefs();
-//   const base::ListValue* const permit_attestation =
-//       prefs->GetList(prefs::kSecurityKeyPermitAttestation);
-//
-//   for (size_t i = 0; i < permit_attestation->GetSize(); i++) {
-//     std::string value;
-//     if (!permit_attestation->GetString(i, &value)) {
-//       continue;
-//     }
-//   }
+CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction::
+    CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction() {}
+
+ExtensionFunction::ResponseAction
+CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction::Run() {
+  std::unique_ptr<cryptotoken_private::IsAppIdHashInEnterpriseContext::Params>
+      params(
+          cryptotoken_private::IsAppIdHashInEnterpriseContext::Params::Create(
+              *args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  Profile* const profile = Profile::FromBrowserContext(browser_context());
+  const PrefService* const prefs = profile->GetPrefs();
+  const base::ListValue* const permit_attestation =
+      prefs->GetList(prefs::kSecurityKeyPermitAttestation);
+
+  return RespondNow(ArgumentList(
+      cryptotoken_private::IsAppIdHashInEnterpriseContext::Results::Create(
+          ContainsAppIdByHash(*permit_attestation, params->app_id_hash))));
+}
+
+CryptotokenPrivateCanAppIdGetAttestationFunction::
+    CryptotokenPrivateCanAppIdGetAttestationFunction() {}
+
+ExtensionFunction::ResponseAction
+CryptotokenPrivateCanAppIdGetAttestationFunction::Run() {
+  std::unique_ptr<cryptotoken_private::CanAppIdGetAttestation::Params> params =
+      cryptotoken_private::CanAppIdGetAttestation::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params);
+  const std::string& app_id = params->options.app_id;
+
+  // If the appId is permitted by the enterprise policy then no permission
+  // prompt is shown.
+  Profile* const profile = Profile::FromBrowserContext(browser_context());
+  const PrefService* const prefs = profile->GetPrefs();
+  const base::ListValue* const permit_attestation =
+      prefs->GetList(prefs::kSecurityKeyPermitAttestation);
+
+  if (std::find_if(permit_attestation->begin(), permit_attestation->end(),
+                   [&app_id](const base::Value& v) -> bool {
+                     return v.GetString() == app_id;
+                   }) != permit_attestation->end()) {
+    return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
+  }
+
+  // If prompting is disabled, allow attestation because that is the historical
+  // behavior.
+  if (!base::FeatureList::IsEnabled(features::kSecurityKeyAttestationPrompt)) {
+    return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
+  }
+
+  // Otherwise, show a permission prompt and pass the user's decision back.
+  const GURL app_id_url(app_id);
+  EXTENSION_FUNCTION_VALIDATE(app_id_url.is_valid());
+
+  content::WebContents* web_contents = nullptr;
+  if (!ExtensionTabUtil::GetTabById(params->options.tab_id, browser_context(),
+                                    true /* include incognito windows */,
+                                    nullptr /* out_browser */,
+                                    nullptr /* out_tab_strip */, &web_contents,
+                                    nullptr /* out_tab_index */)) {
+    return RespondNow(Error("cannot find specified tab"));
+  }
+
+  PermissionRequestManager* permission_request_manager =
+      PermissionRequestManager::FromWebContents(web_contents);
+  if (!permission_request_manager) {
+    return RespondNow(Error("no PermissionRequestManager"));
+  }
+
+  // The created AttestationPermissionRequest deletes itself once complete.
+  permission_request_manager->AddRequest(new AttestationPermissionRequest(
+      app_id_url,
+      base::BindOnce(
+          &CryptotokenPrivateCanAppIdGetAttestationFunction::Complete, this)));
+  return RespondLater();
+}
+
+void CryptotokenPrivateCanAppIdGetAttestationFunction::Complete(bool result) {
+  Respond(OneArgument(std::make_unique<base::Value>(result)));
+}
 
 }  // namespace api
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.h b/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.h
index 55654b1361a..7c92493260b 100644
--- a/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.h
+++ b/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api.h
@@ -7,7 +7,9 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
+#include "base/values.h"
 #include "chrome/browser/extensions/chrome_extension_function_details.h"
 #include "chrome/common/extensions/api/cryptotoken_private.h"
 #include "extensions/browser/extension_function.h"
@@ -33,9 +35,32 @@ class CryptotokenPrivateCanOriginAssertAppIdFunction
   protected:
     ~CryptotokenPrivateCanOriginAssertAppIdFunction() override {}
     ResponseAction Run() override;
+};
+
+class CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction
+    : public UIThreadExtensionFunction {
+ public:
+  CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction();
+  DECLARE_EXTENSION_FUNCTION(
+      "cryptotokenPrivate.isAppIdHashInEnterpriseContext",
+      CRYPTOTOKENPRIVATE_ISAPPIDHASHINENTERPRISECONTEXT)
+
+ protected:
+  ~CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction() override {}
+  ResponseAction Run() override;
+};
+
+class CryptotokenPrivateCanAppIdGetAttestationFunction
+    : public UIThreadExtensionFunction {
+ public:
+  CryptotokenPrivateCanAppIdGetAttestationFunction();
+  DECLARE_EXTENSION_FUNCTION("cryptotokenPrivate.canAppIdGetAttestation",
+                             CRYPTOTOKENPRIVATE_CANAPPIDGETATTESTATION)
 
-  private:
-    ChromeExtensionFunctionDetails chrome_details_;
+ protected:
+  ~CryptotokenPrivateCanAppIdGetAttestationFunction() override {}
+  ResponseAction Run() override;
+  void Complete(bool result);
 };
 
 }  // namespace api
diff --git a/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api_unittest.cc b/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api_unittest.cc
index 937d401039c..a88874bd102 100644
--- a/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/cryptotoken_private/cryptotoken_private_api_unittest.cc
@@ -10,86 +10,254 @@
 #include <utility>
 #include <vector>
 
+#include "base/test/scoped_feature_list.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "chrome/browser/permissions/permission_request_manager.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/ui/permission_bubble/mock_permission_prompt_factory.h"
+#include "chrome/common/chrome_features.h"
+#include "chrome/common/pref_names.h"
+#include "crypto/sha2.h"
+#include "extensions/browser/api_test_utils.h"
+#include "extensions/browser/extension_function_dispatcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using crypto::SHA256HashString;
+
 namespace extensions {
 
 namespace {
 
 using namespace api::cryptotoken_private;
 
+bool GetSingleBooleanResult(UIThreadExtensionFunction* function, bool* result) {
+  const base::ListValue* result_list = function->GetResultList();
+  if (!result_list) {
+    ADD_FAILURE() << "Function has no result list.";
+    return false;
+  }
+
+  if (result_list->GetSize() != 1u) {
+    ADD_FAILURE() << "Invalid number of results.";
+    return false;
+  }
+
+  if (!result_list->GetBoolean(0, result)) {
+    ADD_FAILURE() << "Result is not boolean.";
+    return false;
+  }
+
+  return true;
+}
+
 class CryptoTokenPrivateApiTest : public extensions::ExtensionApiUnittest {
  public:
   CryptoTokenPrivateApiTest() {}
   ~CryptoTokenPrivateApiTest() override {}
 
  protected:
-  bool GetSingleBooleanResult(
-      UIThreadExtensionFunction* function, bool* result) {
-    const base::ListValue* result_list = function->GetResultList();
-    if (!result_list) {
-      LOG(ERROR) << "Function has no result list.";
-      return false;
-    }
+  bool GetCanOriginAssertAppIdResult(const std::string& origin,
+                                     const std::string& app_id,
+                                     bool* out_result) {
+    auto function = base::MakeRefCounted<
+        api::CryptotokenPrivateCanOriginAssertAppIdFunction>();
+    function->set_has_callback(true);
 
-    if (result_list->GetSize() != 1u) {
-      LOG(ERROR) << "Invalid number of results.";
-      return false;
-    }
+    auto args = std::make_unique<base::ListValue>();
+    args->AppendString(origin);
+    args->AppendString(app_id);
 
-    if (!result_list->GetBoolean(0, result)) {
-      LOG(ERROR) << "Result is not boolean.";
+    if (!extension_function_test_utils::RunFunction(
+            function.get(), std::move(args), browser(),
+            extension_function_test_utils::NONE)) {
       return false;
     }
-    return true;
+
+    return GetSingleBooleanResult(function.get(), out_result);
   }
 
-  bool GetCanOriginAssertAppIdResult(const std::string& origin,
-                                     const std::string& appId) {
-    scoped_refptr<api::CryptotokenPrivateCanOriginAssertAppIdFunction> function(
-        new api::CryptotokenPrivateCanOriginAssertAppIdFunction());
+  bool GetAppIdHashInEnterpriseContext(const std::string& app_id,
+                                       bool* out_result) {
+    auto function = base::MakeRefCounted<
+        api::CryptotokenPrivateIsAppIdHashInEnterpriseContextFunction>();
     function->set_has_callback(true);
 
-    std::unique_ptr<base::ListValue> args(new base::ListValue);
-    args->AppendString(origin);
-    args->AppendString(appId);
+    auto args = std::make_unique<base::Value>(base::Value::Type::LIST);
+    args->GetList().emplace_back(
+        base::Value::BlobStorage(app_id.begin(), app_id.end()));
 
-    extension_function_test_utils::RunFunction(
-        function.get(), std::move(args), browser(),
-        extension_function_test_utils::NONE);
+    if (!extension_function_test_utils::RunFunction(
+            function.get(), base::ListValue::From(std::move(args)), browser(),
+            extension_function_test_utils::NONE)) {
+      return false;
+    }
 
-    bool result;
-    GetSingleBooleanResult(function.get(), &result);
-    return result;
+    return GetSingleBooleanResult(function.get(), out_result);
   }
 };
 
 TEST_F(CryptoTokenPrivateApiTest, CanOriginAssertAppId) {
   std::string origin1("https://www.example.com");
 
-  EXPECT_TRUE(GetCanOriginAssertAppIdResult(origin1, origin1));
+  bool result;
+  ASSERT_TRUE(GetCanOriginAssertAppIdResult(origin1, origin1, &result));
+  EXPECT_TRUE(result);
 
   std::string same_origin_appid("https://www.example.com/appId");
-  EXPECT_TRUE(GetCanOriginAssertAppIdResult(origin1, same_origin_appid));
+  ASSERT_TRUE(
+      GetCanOriginAssertAppIdResult(origin1, same_origin_appid, &result));
+  EXPECT_TRUE(result);
   std::string same_etld_plus_one_appid("https://appid.example.com/appId");
-  EXPECT_TRUE(GetCanOriginAssertAppIdResult(origin1, same_etld_plus_one_appid));
+  ASSERT_TRUE(GetCanOriginAssertAppIdResult(origin1, same_etld_plus_one_appid,
+                                            &result));
+  EXPECT_TRUE(result);
   std::string different_etld_plus_one_appid("https://www.different.com/appId");
-  EXPECT_FALSE(GetCanOriginAssertAppIdResult(origin1,
-                                             different_etld_plus_one_appid));
+  ASSERT_TRUE(GetCanOriginAssertAppIdResult(
+      origin1, different_etld_plus_one_appid, &result));
+  EXPECT_FALSE(result);
 
   // For legacy purposes, google.com is allowed to use certain appIds hosted at
   // gstatic.com.
   // TODO(juanlang): remove once the legacy constraints are removed.
   std::string google_origin("https://accounts.google.com");
   std::string gstatic_appid("https://www.gstatic.com/securitykey/origins.json");
-  EXPECT_TRUE(GetCanOriginAssertAppIdResult(google_origin, gstatic_appid));
+  ASSERT_TRUE(
+      GetCanOriginAssertAppIdResult(google_origin, gstatic_appid, &result));
+  EXPECT_TRUE(result);
   // Not all gstatic urls are allowed, just those specifically whitelisted.
   std::string gstatic_otherurl("https://www.gstatic.com/foobar");
-  EXPECT_FALSE(GetCanOriginAssertAppIdResult(google_origin, gstatic_otherurl));
+  ASSERT_TRUE(
+      GetCanOriginAssertAppIdResult(google_origin, gstatic_otherurl, &result));
+  EXPECT_FALSE(result);
+}
+
+TEST_F(CryptoTokenPrivateApiTest, IsAppIdHashInEnterpriseContext) {
+  const std::string example_com("https://example.com/");
+  const std::string example_com_hash(SHA256HashString(example_com));
+  const std::string rp_id_hash(SHA256HashString("example.com"));
+  const std::string foo_com_hash(SHA256HashString("https://foo.com/"));
+
+  bool result;
+  ASSERT_TRUE(GetAppIdHashInEnterpriseContext(example_com_hash, &result));
+  EXPECT_FALSE(result);
+  ASSERT_TRUE(GetAppIdHashInEnterpriseContext(foo_com_hash, &result));
+  EXPECT_FALSE(result);
+  ASSERT_TRUE(GetAppIdHashInEnterpriseContext(rp_id_hash, &result));
+  EXPECT_FALSE(result);
+
+  base::Value::ListStorage permitted_list;
+  permitted_list.emplace_back(example_com);
+  profile()->GetPrefs()->Set(prefs::kSecurityKeyPermitAttestation,
+                             base::Value(permitted_list));
+
+  ASSERT_TRUE(GetAppIdHashInEnterpriseContext(example_com_hash, &result));
+  EXPECT_TRUE(result);
+  ASSERT_TRUE(GetAppIdHashInEnterpriseContext(foo_com_hash, &result));
+  EXPECT_FALSE(result);
+  ASSERT_TRUE(GetAppIdHashInEnterpriseContext(rp_id_hash, &result));
+  EXPECT_FALSE(result);
 }
 
 }  // namespace
 
+class CryptoTokenPermissionTest : public ExtensionApiUnittest {
+ public:
+  CryptoTokenPermissionTest() = default;
+  ~CryptoTokenPermissionTest() override = default;
+
+  void SetUp() override {
+    feature_list_.InitWithFeatures({features::kSecurityKeyAttestationPrompt},
+                                   {});
+
+    ExtensionApiUnittest::SetUp();
+    const GURL url("http://example.com");
+    AddTab(browser(), url);
+
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetWebContentsAt(0);
+    tab_id_ = SessionTabHelper::IdForTab(web_contents);
+    PermissionRequestManager::CreateForWebContents(web_contents);
+    prompt_factory_ = std::make_unique<MockPermissionPromptFactory>(
+        PermissionRequestManager::FromWebContents(web_contents));
+  }
+
+  void TearDown() override {
+    prompt_factory_.reset();
+    ExtensionApiUnittest::TearDown();
+  }
+
+ protected:
+  // CanAppIdGetAttestation calls the cryptotoken private API of the same name
+  // for |app_id| and sets |*out_result| to the result. If |bubble_action| is
+  // not |NONE| then it waits for the permissions prompt to be shown and
+  // performs the given action. Otherwise, the call is expected to be
+  // synchronous.
+  bool CanAppIdGetAttestation(
+      const std::string& app_id,
+      PermissionRequestManager::AutoResponseType bubble_action,
+      bool* out_result) {
+    if (bubble_action != PermissionRequestManager::NONE) {
+      prompt_factory_->set_response_type(bubble_action);
+      prompt_factory_->DocumentOnLoadCompletedInMainFrame();
+    }
+
+    auto function = base::MakeRefCounted<
+        api::CryptotokenPrivateCanAppIdGetAttestationFunction>();
+    function->set_has_callback(true);
+
+    base::Value::DictStorage dict;
+    dict.emplace("appId", std::make_unique<base::Value>(app_id));
+    dict.emplace("tabId", std::make_unique<base::Value>(tab_id_));
+    auto args = std::make_unique<base::Value>(base::Value::Type::LIST);
+    args->GetList().emplace_back(std::move(dict));
+    auto args_list = base::ListValue::From(std::move(args));
+
+    extension_function_test_utils::RunFunction(
+        function.get(), std::move(args_list), browser(),
+        extension_function_test_utils::NONE);
+
+    return GetSingleBooleanResult(function.get(), out_result);
+  }
+
+ private:
+  base::test::ScopedFeatureList feature_list_;
+  int tab_id_ = -1;
+  std::unique_ptr<MockPermissionPromptFactory> prompt_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CryptoTokenPermissionTest);
+};
+
+TEST_F(CryptoTokenPermissionTest, Prompt) {
+  const std::vector<PermissionRequestManager::AutoResponseType> actions = {
+      PermissionRequestManager::ACCEPT_ALL, PermissionRequestManager::DENY_ALL,
+      PermissionRequestManager::DISMISS,
+  };
+
+  for (const auto& action : actions) {
+    SCOPED_TRACE(action);
+
+    bool result = false;
+    ASSERT_TRUE(CanAppIdGetAttestation("https://test.com", action, &result));
+    // The result should only be positive if the user accepted the permissions
+    // prompt.
+    EXPECT_EQ(action == PermissionRequestManager::ACCEPT_ALL, result);
+  }
+}
+
+TEST_F(CryptoTokenPermissionTest, PolicyOverridesPrompt) {
+  const std::string example_com("https://example.com");
+  base::Value::ListStorage permitted_list;
+  permitted_list.emplace_back(example_com);
+  profile()->GetPrefs()->Set(prefs::kSecurityKeyPermitAttestation,
+                             base::Value(permitted_list));
+
+  // If an appId is configured by enterprise policy then attestation requests
+  // should be permitted without showing a prompt.
+  bool result = false;
+  ASSERT_TRUE(CanAppIdGetAttestation(example_com,
+                                     PermissionRequestManager::NONE, &result));
+  EXPECT_TRUE(result);
+}
+
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/dashboard_private/dashboard_private_api.cc b/chromium/chrome/browser/extensions/api/dashboard_private/dashboard_private_api.cc
index 97266d77849..c7d8abdb460 100644
--- a/chromium/chrome/browser/extensions/api/dashboard_private/dashboard_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/dashboard_private/dashboard_private_api.cc
@@ -74,20 +74,19 @@ DashboardPrivateShowPermissionPromptForDelegatedInstallFunction::Run() {
     }
   }
 
-  net::URLRequestContextGetter* context_getter = nullptr;
+  network::mojom::URLLoaderFactory* loader_factory = nullptr;
   if (!icon_url.is_empty()) {
-    context_getter =
-        content::BrowserContext::GetDefaultStoragePartition(browser_context())->
-            GetURLRequestContext();
+    loader_factory =
+        content::BrowserContext::GetDefaultStoragePartition(browser_context())
+            ->GetURLLoaderFactoryForBrowserProcess();
   }
 
   scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
-      this, params_->details.id, params_->details.manifest, icon_url,
-      context_getter);
+      this, params_->details.id, params_->details.manifest, icon_url);
 
   // The helper will call us back via OnWebstoreParseSuccess or
   // OnWebstoreParseFailure.
-  helper->Start();
+  helper->Start(loader_factory);
 
   // Matched with a Release in OnWebstoreParseSuccess/OnWebstoreParseFailure.
   AddRef();
diff --git a/chromium/chrome/browser/extensions/api/debugger/debugger_api.cc b/chromium/chrome/browser/extensions/api/debugger/debugger_api.cc
index 5b5ee80a388..f005243dbba 100644
--- a/chromium/chrome/browser/extensions/api/debugger/debugger_api.cc
+++ b/chromium/chrome/browser/extensions/api/debugger/debugger_api.cc
@@ -13,7 +13,6 @@
 #include <set>
 #include <utility>
 
-#include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ -23,12 +22,11 @@
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
-#include "chrome/browser/devtools/global_confirm_info_bar.h"
 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
+#include "chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/infobars/infobar_service.h"
@@ -36,8 +34,6 @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/grit/generated_resources.h"
-#include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
@@ -58,7 +54,6 @@
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
-#include "ui/base/l10n/l10n_util.h"
 
 using content::DevToolsAgentHost;
 using content::RenderProcessHost;
@@ -89,155 +84,6 @@ void CopyDebuggee(Debuggee* dst, const Debuggee& src) {
     dst->target_id.reset(new std::string(*src.target_id));
 }
 
-
-// ExtensionDevToolsInfoBarDelegate -------------------------------------------
-
-class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
- public:
-  ExtensionDevToolsInfoBarDelegate(const base::Closure& dismissed_callback,
-                                   const std::string& client_name);
-  ~ExtensionDevToolsInfoBarDelegate() override;
-
-  // ConfirmInfoBarDelegate:
-  Type GetInfoBarType() const override;
-  infobars::InfoBarDelegate::InfoBarIdentifier GetIdentifier() const override;
-  bool ShouldExpire(const NavigationDetails& details) const override;
-  void InfoBarDismissed() override;
-  base::string16 GetMessageText() const override;
-  int GetButtons() const override;
-  bool Cancel() override;
-
- private:
-  const base::string16 client_name_;
-  base::Closure dismissed_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsInfoBarDelegate);
-};
-
-ExtensionDevToolsInfoBarDelegate::ExtensionDevToolsInfoBarDelegate(
-    const base::Closure& dismissed_callback,
-    const std::string& client_name)
-    : ConfirmInfoBarDelegate(),
-      client_name_(base::UTF8ToUTF16(client_name)),
-      dismissed_callback_(dismissed_callback) {}
-
-ExtensionDevToolsInfoBarDelegate::~ExtensionDevToolsInfoBarDelegate() {
-}
-
-infobars::InfoBarDelegate::Type
-ExtensionDevToolsInfoBarDelegate::GetInfoBarType() const {
-  return WARNING_TYPE;
-}
-
-infobars::InfoBarDelegate::InfoBarIdentifier
-ExtensionDevToolsInfoBarDelegate::GetIdentifier() const {
-  return EXTENSION_DEV_TOOLS_INFOBAR_DELEGATE;
-}
-
-bool ExtensionDevToolsInfoBarDelegate::ShouldExpire(
-    const NavigationDetails& details) const {
-  return false;
-}
-
-void ExtensionDevToolsInfoBarDelegate::InfoBarDismissed() {
-  DCHECK(!dismissed_callback_.is_null());
-  // Use ResetAndReturn() since running the callback may delete |this|.
-  base::ResetAndReturn(&dismissed_callback_).Run();
-}
-
-base::string16 ExtensionDevToolsInfoBarDelegate::GetMessageText() const {
-  return l10n_util::GetStringFUTF16(IDS_DEV_TOOLS_INFOBAR_LABEL, client_name_);
-}
-
-int ExtensionDevToolsInfoBarDelegate::GetButtons() const {
-  return BUTTON_CANCEL;
-}
-
-bool ExtensionDevToolsInfoBarDelegate::Cancel() {
-  InfoBarDismissed();
-  // InfoBarDismissed() will have closed us already.
-  return false;
-}
-
-// ExtensionDevToolsInfoBar ---------------------------------------------------
-
-class ExtensionDevToolsInfoBar;
-using ExtensionInfoBars =
-    std::map<std::string, ExtensionDevToolsInfoBar*>;
-base::LazyInstance<ExtensionInfoBars>::Leaky g_extension_info_bars =
-    LAZY_INSTANCE_INITIALIZER;
-
-class ExtensionDevToolsInfoBar {
- public:
-  static ExtensionDevToolsInfoBar* Create(
-      const std::string& extension_id,
-      const std::string& extension_name,
-      ExtensionDevToolsClientHost* client_host,
-      const base::Closure& dismissed_callback);
-  void Remove(ExtensionDevToolsClientHost* client_host);
-
- private:
-  ExtensionDevToolsInfoBar(const std::string& extension_id,
-                           const std::string& extension_name);
-  ~ExtensionDevToolsInfoBar();
-  void InfoBarDismissed();
-
-  std::string extension_id_;
-  std::map<ExtensionDevToolsClientHost*, base::Closure> callbacks_;
-  base::WeakPtr<GlobalConfirmInfoBar> infobar_;
-};
-
-// static
-ExtensionDevToolsInfoBar* ExtensionDevToolsInfoBar::Create(
-      const std::string& extension_id,
-      const std::string& extension_name,
-      ExtensionDevToolsClientHost* client_host,
-      const base::Closure& dismissed_callback) {
-  ExtensionInfoBars::iterator it =
-      g_extension_info_bars.Get().find(extension_id);
-  ExtensionDevToolsInfoBar* infobar = nullptr;
-  if (it != g_extension_info_bars.Get().end())
-    infobar = it->second;
-  else
-    infobar = new ExtensionDevToolsInfoBar(extension_id, extension_name);
-  infobar->callbacks_[client_host] = dismissed_callback;
-  return infobar;
-}
-
-ExtensionDevToolsInfoBar::ExtensionDevToolsInfoBar(
-    const std::string& extension_id,
-    const std::string& extension_name)
-    : extension_id_(extension_id) {
-  g_extension_info_bars.Get()[extension_id] = this;
-
-  // This class closes the |infobar_|, so it's safe to pass Unretained(this).
-  std::unique_ptr<ExtensionDevToolsInfoBarDelegate> delegate(
-      new ExtensionDevToolsInfoBarDelegate(
-          base::Bind(&ExtensionDevToolsInfoBar::InfoBarDismissed,
-                     base::Unretained(this)),
-          extension_name));
-  infobar_ = GlobalConfirmInfoBar::Show(std::move(delegate));
-}
-
-ExtensionDevToolsInfoBar::~ExtensionDevToolsInfoBar() {
-  g_extension_info_bars.Get().erase(extension_id_);
-  if (infobar_)
-    infobar_->Close();
-}
-
-void ExtensionDevToolsInfoBar::Remove(
-    ExtensionDevToolsClientHost* client_host) {
-  callbacks_.erase(client_host);
-  if (callbacks_.empty())
-    delete this;
-}
-
-void ExtensionDevToolsInfoBar::InfoBarDismissed() {
-  std::map<ExtensionDevToolsClientHost*, base::Closure> copy = callbacks_;
-  for (const auto& pair : copy)
-    pair.second.Run();
-}
-
 }  // namespace
 
 // ExtensionDevToolsClientHost ------------------------------------------------
@@ -306,8 +152,6 @@ class ExtensionDevToolsClientHost : public content::DevToolsAgentHostClient,
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
-// ExtensionDevToolsClientHost ------------------------------------------------
-
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     Profile* profile,
     DevToolsAgentHost* agent_host,
@@ -408,7 +252,7 @@ void ExtensionDevToolsClientHost::SendDetachedEvent() {
   std::unique_ptr<base::ListValue> args(
       OnDetach::Create(debuggee_, detach_reason_));
   auto event =
-      base::MakeUnique<Event>(events::DEBUGGER_ON_DETACH, OnDetach::kEventName,
+      std::make_unique<Event>(events::DEBUGGER_ON_DETACH, OnDetach::kEventName,
                               std::move(args), profile_);
   EventRouter::Get(profile_)
       ->DispatchEventToExtension(extension_id_, std::move(event));
@@ -456,7 +300,7 @@ void ExtensionDevToolsClientHost::DispatchProtocolMessage(
     std::unique_ptr<base::ListValue> args(
         OnEvent::Create(debuggee_, method_name, params));
     auto event =
-        base::MakeUnique<Event>(events::DEBUGGER_ON_EVENT, OnEvent::kEventName,
+        std::make_unique<Event>(events::DEBUGGER_ON_EVENT, OnEvent::kEventName,
                                 std::move(args), profile_);
     EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, std::move(event));
diff --git a/chromium/chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.cc b/chromium/chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.cc
new file mode 100644
index 00000000000..6b187e3a93c
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.cc
@@ -0,0 +1,144 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.h"
+
+#include <memory>
+
+#include "base/callback_helpers.h"
+#include "base/lazy_instance.h"
+#include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/devtools/global_confirm_info_bar.h"
+#include "chrome/grit/generated_resources.h"
+#include "components/infobars/core/confirm_infobar_delegate.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace extensions {
+
+namespace {
+
+// The InfoBarDelegate that ExtensionDevToolsInfoBar shows.
+class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
+ public:
+  ExtensionDevToolsInfoBarDelegate(const base::Closure& dismissed_callback,
+                                   const std::string& client_name);
+  ~ExtensionDevToolsInfoBarDelegate() override;
+
+  // ConfirmInfoBarDelegate:
+  Type GetInfoBarType() const override;
+  infobars::InfoBarDelegate::InfoBarIdentifier GetIdentifier() const override;
+  bool ShouldExpire(const NavigationDetails& details) const override;
+  void InfoBarDismissed() override;
+  base::string16 GetMessageText() const override;
+  int GetButtons() const override;
+  bool Cancel() override;
+
+ private:
+  const base::string16 client_name_;
+  base::Closure dismissed_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsInfoBarDelegate);
+};
+
+ExtensionDevToolsInfoBarDelegate::ExtensionDevToolsInfoBarDelegate(
+    const base::Closure& dismissed_callback,
+    const std::string& client_name)
+    : ConfirmInfoBarDelegate(),
+      client_name_(base::UTF8ToUTF16(client_name)),
+      dismissed_callback_(dismissed_callback) {}
+
+ExtensionDevToolsInfoBarDelegate::~ExtensionDevToolsInfoBarDelegate() {}
+
+infobars::InfoBarDelegate::Type
+ExtensionDevToolsInfoBarDelegate::GetInfoBarType() const {
+  return WARNING_TYPE;
+}
+
+infobars::InfoBarDelegate::InfoBarIdentifier
+ExtensionDevToolsInfoBarDelegate::GetIdentifier() const {
+  return EXTENSION_DEV_TOOLS_INFOBAR_DELEGATE;
+}
+
+bool ExtensionDevToolsInfoBarDelegate::ShouldExpire(
+    const NavigationDetails& details) const {
+  return false;
+}
+
+void ExtensionDevToolsInfoBarDelegate::InfoBarDismissed() {
+  DCHECK(!dismissed_callback_.is_null());
+  // Use ResetAndReturn() since running the callback may delete |this|.
+  base::ResetAndReturn(&dismissed_callback_).Run();
+}
+
+base::string16 ExtensionDevToolsInfoBarDelegate::GetMessageText() const {
+  return l10n_util::GetStringFUTF16(IDS_DEV_TOOLS_INFOBAR_LABEL, client_name_);
+}
+
+int ExtensionDevToolsInfoBarDelegate::GetButtons() const {
+  return BUTTON_CANCEL;
+}
+
+bool ExtensionDevToolsInfoBarDelegate::Cancel() {
+  InfoBarDismissed();
+  // InfoBarDismissed() will have closed us already.
+  return false;
+}
+
+using ExtensionInfoBars = std::map<std::string, ExtensionDevToolsInfoBar*>;
+base::LazyInstance<ExtensionInfoBars>::Leaky g_extension_info_bars =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+// static
+ExtensionDevToolsInfoBar* ExtensionDevToolsInfoBar::Create(
+    const std::string& extension_id,
+    const std::string& extension_name,
+    ExtensionDevToolsClientHost* client_host,
+    const base::Closure& dismissed_callback) {
+  ExtensionInfoBars::iterator it =
+      g_extension_info_bars.Get().find(extension_id);
+  ExtensionDevToolsInfoBar* infobar = nullptr;
+  if (it != g_extension_info_bars.Get().end())
+    infobar = it->second;
+  else
+    infobar = new ExtensionDevToolsInfoBar(extension_id, extension_name);
+  infobar->callbacks_[client_host] = dismissed_callback;
+  return infobar;
+}
+
+ExtensionDevToolsInfoBar::ExtensionDevToolsInfoBar(
+    const std::string& extension_id,
+    const std::string& extension_name)
+    : extension_id_(extension_id) {
+  g_extension_info_bars.Get()[extension_id] = this;
+
+  // This class closes the |infobar_|, so it's safe to pass Unretained(this).
+  auto delegate = std::make_unique<ExtensionDevToolsInfoBarDelegate>(
+      base::Bind(&ExtensionDevToolsInfoBar::InfoBarDismissed,
+                 base::Unretained(this)),
+      extension_name);
+  infobar_ = GlobalConfirmInfoBar::Show(std::move(delegate));
+}
+
+ExtensionDevToolsInfoBar::~ExtensionDevToolsInfoBar() {
+  g_extension_info_bars.Get().erase(extension_id_);
+  if (infobar_)
+    infobar_->Close();
+}
+
+void ExtensionDevToolsInfoBar::Remove(
+    ExtensionDevToolsClientHost* client_host) {
+  callbacks_.erase(client_host);
+  if (callbacks_.empty())
+    delete this;
+}
+
+void ExtensionDevToolsInfoBar::InfoBarDismissed() {
+  std::map<ExtensionDevToolsClientHost*, base::Closure> copy = callbacks_;
+  for (const auto& pair : copy)
+    pair.second.Run();
+}
+
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.h b/chromium/chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.h
new file mode 100644
index 00000000000..63ec9a39a82
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/debugger/extension_dev_tools_infobar.h
@@ -0,0 +1,43 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_DEBUGGER_EXTENSION_DEV_TOOLS_INFOBAR_H_
+#define CHROME_BROWSER_EXTENSIONS_API_DEBUGGER_EXTENSION_DEV_TOOLS_INFOBAR_H_
+
+#include <map>
+#include <string>
+
+#include "base/callback_forward.h"
+#include "base/memory/weak_ptr.h"
+
+class GlobalConfirmInfoBar;
+
+namespace extensions {
+class ExtensionDevToolsClientHost;
+
+// An infobar used to globally warn users that an extension is debugging the
+// browser (which has security consequences).
+class ExtensionDevToolsInfoBar {
+ public:
+  static ExtensionDevToolsInfoBar* Create(
+      const std::string& extension_id,
+      const std::string& extension_name,
+      ExtensionDevToolsClientHost* client_host,
+      const base::Closure& dismissed_callback);
+  void Remove(ExtensionDevToolsClientHost* client_host);
+
+ private:
+  ExtensionDevToolsInfoBar(const std::string& extension_id,
+                           const std::string& extension_name);
+  ~ExtensionDevToolsInfoBar();
+  void InfoBarDismissed();
+
+  std::string extension_id_;
+  std::map<ExtensionDevToolsClientHost*, base::Closure> callbacks_;
+  base::WeakPtr<GlobalConfirmInfoBar> infobar_;
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_DEBUGGER_EXTENSION_DEV_TOOLS_INFOBAR_H_
diff --git a/chromium/chrome/browser/extensions/api/declarative/rules_registry_with_cache_unittest.cc b/chromium/chrome/browser/extensions/api/declarative/rules_registry_with_cache_unittest.cc
index 8a24e609db7..d9059dbe147 100644
--- a/chromium/chrome/browser/extensions/api/declarative/rules_registry_with_cache_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative/rules_registry_with_cache_unittest.cc
@@ -8,8 +8,9 @@
 // implementation of RulesRegistryWithCache as a proxy for
 // RulesRegistryWithCache.
 
+#include <memory>
+
 #include "base/command_line.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/browser/extensions/test_extension_system.h"
@@ -243,11 +244,11 @@ TEST_F(RulesRegistryWithCacheTest, DeclarativeRulesStored) {
   EXPECT_TRUE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
 
   extension_prefs->UpdateExtensionPref(extension1_->id(), rules_stored_key,
-                                       base::MakeUnique<base::Value>(false));
+                                       std::make_unique<base::Value>(false));
   EXPECT_FALSE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
 
   extension_prefs->UpdateExtensionPref(extension1_->id(), rules_stored_key,
-                                       base::MakeUnique<base::Value>(true));
+                                       std::make_unique<base::Value>(true));
   EXPECT_TRUE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
 
   // 2. Test writing behavior.
@@ -320,7 +321,7 @@ TEST_F(RulesRegistryWithCacheTest, RulesStoredFlagMultipleRegistries) {
 
   // Update the flag for the first registry.
   extension_prefs->UpdateExtensionPref(extension1_->id(), rules_stored_key1,
-                                       base::MakeUnique<base::Value>(false));
+                                       std::make_unique<base::Value>(false));
   EXPECT_FALSE(cache_delegate1->GetDeclarativeRulesStored(extension1_->id()));
   EXPECT_TRUE(cache_delegate2->GetDeclarativeRulesStored(extension1_->id()));
 }
diff --git a/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.cc b/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.cc
index be2b6621c3e..7e3a26d38d1 100644
--- a/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry.cc
@@ -6,7 +6,6 @@
 
 #include "base/bind.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ -180,7 +179,7 @@ ChromeContentRulesRegistry::CreateRule(
 
   // Note: |api_rule| may contain tags, but these are ignored.
 
-  return base::MakeUnique<ContentRule>(extension, std::move(conditions),
+  return std::make_unique<ContentRule>(extension, std::move(conditions),
                                        std::move(actions), *api_rule.priority);
 }
 
diff --git a/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry_unittest.cc b/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry_unittest.cc
index e33493a66f2..cedb5c77888 100644
--- a/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_content/chrome_content_rules_registry_unittest.cc
@@ -6,7 +6,6 @@
 
 #include "base/bind.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/api/declarative_content/content_predicate.h"
 #include "chrome/browser/extensions/api/declarative_content/content_predicate_evaluator.h"
@@ -58,7 +57,7 @@ class TestPredicateEvaluator : public ContentPredicateEvaluator {
       const base::Value& value,
       std::string* error) override {
     RequestEvaluationIfSpecified();
-    return base::MakeUnique<TestPredicate>(this);
+    return std::make_unique<TestPredicate>(this);
   }
 
   void TrackPredicates(
diff --git a/chromium/chrome/browser/extensions/api/declarative_content/content_action.cc b/chromium/chrome/browser/extensions/api/declarative_content/content_action.cc
index f4df5b42700..fa344ec3319 100644
--- a/chromium/chrome/browser/extensions/api/declarative_content/content_action.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_content/content_action.cc
@@ -347,7 +347,7 @@ void RequestContentScript::InitScript(const HostID& host_id,
        it != script_data.css_file_names.end(); ++it) {
     GURL url = extension->GetResourceURL(*it);
     ExtensionResource resource = extension->GetResource(*it);
-    script_.css_scripts().push_back(base::MakeUnique<UserScript::File>(
+    script_.css_scripts().push_back(std::make_unique<UserScript::File>(
         resource.extension_root(), resource.relative_path(), url));
   }
   for (std::vector<std::string>::const_iterator it =
@@ -355,7 +355,7 @@ void RequestContentScript::InitScript(const HostID& host_id,
        it != script_data.js_file_names.end(); ++it) {
     GURL url = extension->GetResourceURL(*it);
     ExtensionResource resource = extension->GetResource(*it);
-    script_.js_scripts().push_back(base::MakeUnique<UserScript::File>(
+    script_.js_scripts().push_back(std::make_unique<UserScript::File>(
         resource.extension_root(), resource.relative_path(), url));
   }
 }
diff --git a/chromium/chrome/browser/extensions/api/declarative_net_request/declarative_net_request_browsertest.cc b/chromium/chrome/browser/extensions/api/declarative_net_request/declarative_net_request_browsertest.cc
index 0be10ba489a..3ae612a992c 100644
--- a/chromium/chrome/browser/extensions/api/declarative_net_request/declarative_net_request_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_net_request/declarative_net_request_browsertest.cc
@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 #include <stddef.h>
+
 #include <algorithm>
+#include <memory>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ -12,13 +14,20 @@
 #include "base/path_service.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/values.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
-#include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_util.h"
+#include "chrome/browser/extensions/load_error_reporter.h"
+#include "chrome/browser/net/profile_network_context_service.h"
+#include "chrome/browser/net/profile_network_context_service_factory.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/webui_url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
+#include "components/prefs/pref_service.h"
+#include "components/proxy_config/proxy_config_dictionary.h"
+#include "components/proxy_config/proxy_config_pref_names.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/test/browser_test_utils.h"
@@ -26,6 +35,7 @@
 #include "extensions/browser/api/declarative_net_request/ruleset_manager.h"
 #include "extensions/browser/api/declarative_net_request/ruleset_matcher.h"
 #include "extensions/browser/api/declarative_net_request/test_utils.h"
+#include "extensions/browser/api/web_request/web_request_info.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_util.h"
@@ -70,9 +80,9 @@ class URLRequestMonitor : public RulesetManager::TestObserver {
 
  private:
   // RulesetManager::TestObserver implementation.
-  void OnShouldBlockRequest(const net::URLRequest& request,
+  void OnShouldBlockRequest(const WebRequestInfo& request,
                             bool is_incognito_context) override {
-    if (request.url() == url_)
+    if (request.url == url_)
       GetAndResetRequestSeen(true);
   }
 
@@ -172,7 +182,7 @@ class DeclarativeNetRequestBrowserTest
     content::RunAllTasksUntilIdle();
 
     // Ensure no load errors were reported.
-    EXPECT_TRUE(ExtensionErrorReporter::GetInstance()->GetErrors()->empty());
+    EXPECT_TRUE(LoadErrorReporter::GetInstance()->GetErrors()->empty());
 
     tester.ExpectTotalCount(kIndexRulesTimeHistogram, 1);
     tester.ExpectTotalCount(kIndexAndPersistRulesTimeHistogram, 1);
@@ -896,149 +906,6 @@ IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestBrowserTest,
   }
 }
 
-// Tests the "resourceTypes" and "excludedResourceTypes" fields of a declarative
-// rule condition.
-IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestBrowserTest,
-                       BlockRequests_ResourceTypes) {
-  // TODO(crbug.com/696822): Add tests for "object", "ping", "other", "font".
-  enum ResourceTypeMask {
-    kNone = 0,
-    kSubframe = 1 << 0,
-    kStylesheet = 1 << 1,
-    kScript = 1 << 2,
-    kImage = 1 << 3,
-    kXHR = 1 << 4,
-    kMedia = 1 << 5,
-    kWebSocket = 1 << 6,
-    kAll = (1 << 7) - 1
-  };
-
-  struct {
-    std::string domain;
-    size_t id;
-    std::vector<std::string> resource_types;
-    std::vector<std::string> excluded_resource_types;
-  } rules_data[] = {
-      {"block_subframe.com", 1, {"sub_frame"}, {}},
-      {"block_stylesheet.com", 2, {"stylesheet"}, {}},
-      {"block_script.com", 3, {"script"}, {}},
-      {"block_image.com", 4, {"image"}, {}},
-      {"block_xhr.com", 5, {"xmlhttprequest"}, {}},
-      {"block_media.com", 6, {"media"}, {}},
-      {"block_websocket.com", 7, {"websocket"}, {}},
-      {"block_image_and_stylesheet.com", 8, {"image", "stylesheet"}, {}},
-      {"block_subframe_and_xhr.com", 11, {"sub_frame", "xmlhttprequest"}, {}},
-      // With renderer side navigation, the main frame origin serves as the
-      // initiator for main frame page loads. Hence to ensure that the main
-      // frame page load is not blocked, also exclude the "other" resource type,
-      // which is used for main frame requests currently.
-      // TODO(crbug.com/696822): Change "other" to "main_frame" once it is
-      // implemented.
-      {"block_all.com", 9, {}, {"other"}},
-      {"block_all_but_xhr_and_script.com",
-       10,
-       {},
-       {"xmlhttprequest", "script", "other"}},
-  };
-
-  std::vector<TestRule> rules;
-  for (const auto& rule_data : rules_data) {
-    TestRule rule = CreateGenericRule();
-
-    // The "resourceTypes" property (i.e. |rule.condition->resource_types|)
-    // should not be an empty list. It should either be omitted or be a non-
-    // empty list.
-    if (rule_data.resource_types.empty())
-      rule.condition->resource_types = base::nullopt;
-    else
-      rule.condition->resource_types = rule_data.resource_types;
-
-    rule.condition->excluded_resource_types = rule_data.excluded_resource_types;
-    rule.id = rule_data.id;
-    rule.condition->domains = std::vector<std::string>({rule_data.domain});
-    // Don't specify the urlFilter, which should behaves the same as "*".
-    rule.condition->url_filter = base::nullopt;
-    rules.push_back(rule);
-  }
-  ASSERT_NO_FATAL_FAILURE(LoadExtensionWithRules(rules));
-
-  struct {
-    std::string hostname;
-    int blocked_mask;
-  } test_cases[] = {
-      {"block_subframe.com", kSubframe},
-      {"block_stylesheet.com", kStylesheet},
-      {"block_script.com", kScript},
-      {"block_image.com", kImage},
-      {"block_xhr.com", kXHR},
-      {"block_media.com", kMedia},
-      {"block_websocket.com", kWebSocket},
-      {"block_image_and_stylesheet.com", kImage | kStylesheet},
-      {"block_subframe_and_xhr.com", kSubframe | kXHR},
-      {"block_all.com", kAll},
-      {"block_all_but_xhr_and_script.com", kAll & ~kXHR & ~kScript},
-      {"block_none.com", kNone}};
-
-  // Start a web socket test server to test the websocket resource type.
-  net::SpawnedTestServer websocket_test_server(
-      net::SpawnedTestServer::TYPE_WS, net::GetWebSocketTestDataDirectory());
-  ASSERT_TRUE(websocket_test_server.Start());
-
-  // The |websocket_url| will echo the message we send to it.
-  GURL websocket_url = websocket_test_server.GetURL("echo-with-no-extension");
-
-  auto execute_script = [](content::RenderFrameHost* frame,
-                           const std::string& script) {
-    bool subresource_loaded = false;
-    EXPECT_TRUE(content::ExecuteScriptAndExtractBool(frame, script,
-                                                     &subresource_loaded));
-    return subresource_loaded;
-  };
-
-  for (const auto& test_case : test_cases) {
-    GURL url = embedded_test_server()->GetURL(test_case.hostname,
-                                              "/subresources.html");
-    SCOPED_TRACE(base::StringPrintf("Testing %s", url.spec().c_str()));
-
-    ui_test_utils::NavigateToURL(browser(), url);
-    ASSERT_EQ(content::PAGE_TYPE_NORMAL, GetPageType());
-
-    content::RenderFrameHost* frame = GetMainFrame();
-
-    // sub-frame.
-    EXPECT_EQ(
-        !(test_case.blocked_mask & kSubframe),
-        execute_script(frame,
-                       "domAutomationController.send(!!window.frameLoaded);"));
-
-    // stylesheet
-    EXPECT_EQ(!(test_case.blocked_mask & kStylesheet),
-              execute_script(frame, "testStylesheet();"));
-
-    // script
-    EXPECT_EQ(!(test_case.blocked_mask & kScript),
-              execute_script(frame, "testScript();"));
-
-    // image
-    EXPECT_EQ(!(test_case.blocked_mask & kImage),
-              execute_script(frame, "testImage();"));
-
-    // xhr
-    EXPECT_EQ(!(test_case.blocked_mask & kXHR),
-              execute_script(frame, "testXHR();"));
-
-    // media
-    EXPECT_EQ(!(test_case.blocked_mask & kMedia),
-              execute_script(frame, "testMedia();"));
-
-    // websocket
-    EXPECT_EQ(!(test_case.blocked_mask & kWebSocket),
-              execute_script(frame,
-                             base::StringPrintf("testWebSocket('%s');",
-                                                websocket_url.spec().c_str())));
-  }
-}
-
 // Ensure extensions can't intercept chrome:// urls.
 IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestBrowserTest, ChromeURLS) {
   // Have the extension block all chrome:// urls.
@@ -1152,12 +1019,212 @@ IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestBrowserTest, RendererCacheCleared) {
   content::RunAllTasksUntilIdle();
 }
 
+// Tests that proxy requests aren't intercepted. See https://crbug.com/794674.
+IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestBrowserTest,
+                       PacRequestsBypassRules) {
+  // Load the extension.
+  std::vector<TestRule> rules;
+  TestRule rule = CreateGenericRule();
+  rule.condition->url_filter = std::string("*pac");
+  rule.id = 1;
+  rules.push_back(rule);
+  ASSERT_NO_FATAL_FAILURE(LoadExtensionWithRules(rules));
+
+  // Configure a PAC script. Need to do this after the extension is loaded, so
+  // that the PAC isn't already loaded by the time the extension starts
+  // affecting requests.
+  PrefService* pref_service = browser()->profile()->GetPrefs();
+  pref_service->Set(proxy_config::prefs::kProxy,
+                    *ProxyConfigDictionary::CreatePacScript(
+                        embedded_test_server()->GetURL("/self.pac").spec(),
+                        true /* pac_mandatory */));
+  // Flush the proxy configuration change over the Mojo pipe to avoid any races.
+  ProfileNetworkContextServiceFactory::GetForContext(browser()->profile())
+      ->FlushProxyConfigMonitorForTesting();
+
+  // Verify that the extension can't intercept the network request.
+  ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(
+                                              "/pages_with_script/page.html"));
+  EXPECT_TRUE(WasFrameWithScriptLoaded(GetMainFrame()));
+  EXPECT_EQ(content::PAGE_TYPE_NORMAL, GetPageType());
+}
+
+// Fixture to test the "resourceTypes" and "excludedResourceTypes" fields of a
+// declarative rule condition.
+class DeclarativeNetRequestResourceTypeBrowserTest
+    : public DeclarativeNetRequestBrowserTest {
+ public:
+  DeclarativeNetRequestResourceTypeBrowserTest() {}
+
+ protected:
+  // TODO(crbug.com/696822): Add tests for "object", "ping", "other", "font".
+  enum ResourceTypeMask {
+    kNone = 0,
+    kSubframe = 1 << 0,
+    kStylesheet = 1 << 1,
+    kScript = 1 << 2,
+    kImage = 1 << 3,
+    kXHR = 1 << 4,
+    kMedia = 1 << 5,
+    kWebSocket = 1 << 6,
+    kAll = (1 << 7) - 1
+  };
+
+  struct TestCase {
+    std::string hostname;
+    int blocked_mask;
+  };
+
+  void RunTests(const std::vector<TestCase>& test_cases) {
+    // Start a web socket test server to test the websocket resource type.
+    net::SpawnedTestServer websocket_test_server(
+        net::SpawnedTestServer::TYPE_WS, net::GetWebSocketTestDataDirectory());
+    ASSERT_TRUE(websocket_test_server.Start());
+
+    // The |websocket_url| will echo the message we send to it.
+    GURL websocket_url = websocket_test_server.GetURL("echo-with-no-extension");
+
+    auto execute_script = [](content::RenderFrameHost* frame,
+                             const std::string& script) {
+      bool subresource_loaded = false;
+      EXPECT_TRUE(content::ExecuteScriptAndExtractBool(frame, script,
+                                                       &subresource_loaded));
+      return subresource_loaded;
+    };
+
+    for (const auto& test_case : test_cases) {
+      GURL url = embedded_test_server()->GetURL(test_case.hostname,
+                                                "/subresources.html");
+      SCOPED_TRACE(base::StringPrintf("Testing %s", url.spec().c_str()));
+
+      ui_test_utils::NavigateToURL(browser(), url);
+      ASSERT_EQ(content::PAGE_TYPE_NORMAL, GetPageType());
+
+      content::RenderFrameHost* frame = GetMainFrame();
+
+      // sub-frame.
+      EXPECT_EQ(
+          !(test_case.blocked_mask & kSubframe),
+          execute_script(
+              frame, "domAutomationController.send(!!window.frameLoaded);"));
+
+      // stylesheet
+      EXPECT_EQ(!(test_case.blocked_mask & kStylesheet),
+                execute_script(frame, "testStylesheet();"));
+
+      // script
+      EXPECT_EQ(!(test_case.blocked_mask & kScript),
+                execute_script(frame, "testScript();"));
+
+      // image
+      EXPECT_EQ(!(test_case.blocked_mask & kImage),
+                execute_script(frame, "testImage();"));
+
+      // xhr
+      EXPECT_EQ(!(test_case.blocked_mask & kXHR),
+                execute_script(frame, "testXHR();"));
+
+      // media
+      EXPECT_EQ(!(test_case.blocked_mask & kMedia),
+                execute_script(frame, "testMedia();"));
+
+      // websocket
+      EXPECT_EQ(!(test_case.blocked_mask & kWebSocket),
+                execute_script(
+                    frame, base::StringPrintf("testWebSocket('%s');",
+                                              websocket_url.spec().c_str())));
+    }
+  }
+
+  // Loads an extension to test blocking different resource types.
+  void LoadExtension() {
+    struct {
+      std::string domain;
+      size_t id;
+      std::vector<std::string> resource_types;
+      std::vector<std::string> excluded_resource_types;
+    } rules_data[] = {
+        {"block_subframe.com", 1, {"sub_frame"}, {}},
+        {"block_stylesheet.com", 2, {"stylesheet"}, {}},
+        {"block_script.com", 3, {"script"}, {}},
+        {"block_image.com", 4, {"image"}, {}},
+        {"block_xhr.com", 5, {"xmlhttprequest"}, {}},
+        {"block_media.com", 6, {"media"}, {}},
+        {"block_websocket.com", 7, {"websocket"}, {}},
+        {"block_image_and_stylesheet.com", 8, {"image", "stylesheet"}, {}},
+        {"block_subframe_and_xhr.com", 11, {"sub_frame", "xmlhttprequest"}, {}},
+        // With renderer side navigation, the main frame origin serves as the
+        // initiator for main frame page loads. Hence to ensure that the main
+        // frame page load is not blocked, also exclude the "other" resource
+        // type, which is used for main frame requests currently.
+        // TODO(crbug.com/696822): Change "other" to "main_frame" once it is
+        // implemented.
+        {"block_all.com", 9, {}, {"other"}},
+        {"block_all_but_xhr_and_script.com",
+         10,
+         {},
+         {"xmlhttprequest", "script", "other"}},
+    };
+
+    std::vector<TestRule> rules;
+    for (const auto& rule_data : rules_data) {
+      TestRule rule = CreateGenericRule();
+
+      // The "resourceTypes" property (i.e. |rule.condition->resource_types|)
+      // should not be an empty list. It should either be omitted or be a non-
+      // empty list.
+      if (rule_data.resource_types.empty())
+        rule.condition->resource_types = base::nullopt;
+      else
+        rule.condition->resource_types = rule_data.resource_types;
+
+      rule.condition->excluded_resource_types =
+          rule_data.excluded_resource_types;
+      rule.id = rule_data.id;
+      rule.condition->domains = std::vector<std::string>({rule_data.domain});
+      // Don't specify the urlFilter, which should behaves the same as "*".
+      rule.condition->url_filter = base::nullopt;
+      rules.push_back(rule);
+    }
+    LoadExtensionWithRules(rules);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeclarativeNetRequestResourceTypeBrowserTest);
+};
+
+// These are split into two tests to prevent a timeout. See crbug.com/787957.
+IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestResourceTypeBrowserTest, Test1) {
+  ASSERT_NO_FATAL_FAILURE(LoadExtension());
+  RunTests({{"block_subframe.com", kSubframe},
+            {"block_stylesheet.com", kStylesheet},
+            {"block_script.com", kScript},
+            {"block_image.com", kImage},
+            {"block_xhr.com", kXHR},
+            {"block_media.com", kMedia}});
+}
+
+IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestResourceTypeBrowserTest, Test2) {
+  ASSERT_NO_FATAL_FAILURE(LoadExtension());
+  RunTests({{"block_websocket.com", kWebSocket},
+            {"block_image_and_stylesheet.com", kImage | kStylesheet},
+            {"block_subframe_and_xhr.com", kSubframe | kXHR},
+            {"block_all.com", kAll},
+            {"block_all_but_xhr_and_script.com", kAll & ~kXHR & ~kScript},
+            {"block_none.com", kNone}});
+}
+
 INSTANTIATE_TEST_CASE_P(,
                         DeclarativeNetRequestBrowserTest,
                         ::testing::Values(ExtensionLoadType::PACKED,
                                           ExtensionLoadType::UNPACKED));
 
 INSTANTIATE_TEST_CASE_P(,
+                        DeclarativeNetRequestResourceTypeBrowserTest,
+                        ::testing::Values(ExtensionLoadType::PACKED,
+                                          ExtensionLoadType::UNPACKED));
+
+INSTANTIATE_TEST_CASE_P(,
                         DeclarativeNetRequestBrowserTest_Packed,
                         ::testing::Values(ExtensionLoadType::PACKED));
 
diff --git a/chromium/chrome/browser/extensions/api/declarative_net_request/rule_indexing_unittest.cc b/chromium/chrome/browser/extensions/api/declarative_net_request/rule_indexing_unittest.cc
index 6d464d8f61c..e8b3fffeca9 100644
--- a/chromium/chrome/browser/extensions/api/declarative_net_request/rule_indexing_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_net_request/rule_indexing_unittest.cc
@@ -14,8 +14,8 @@
 #include "base/test/histogram_tester.h"
 #include "chrome/browser/extensions/api/declarative_net_request/dnr_test_base.h"
 #include "chrome/browser/extensions/chrome_test_extension_loader.h"
-#include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/load_error_reporter.h"
 #include "extensions/browser/api/declarative_net_request/constants.h"
 #include "extensions/browser/api/declarative_net_request/parse_info.h"
 #include "extensions/browser/api/declarative_net_request/test_utils.h"
@@ -149,8 +149,8 @@ class RuleIndexingTest : public DNRTestBase {
     }
   }
 
-  ExtensionErrorReporter* error_reporter() {
-    return ExtensionErrorReporter::GetInstance();
+  LoadErrorReporter* error_reporter() {
+    return LoadErrorReporter::GetInstance();
   }
 
   std::vector<TestRule> rules_list_;
diff --git a/chromium/chrome/browser/extensions/api/declarative_net_request/ruleset_manager_unittest.cc b/chromium/chrome/browser/extensions/api/declarative_net_request/ruleset_manager_unittest.cc
index 5d08c451723..eec02539495 100644
--- a/chromium/chrome/browser/extensions/api/declarative_net_request/ruleset_manager_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_net_request/ruleset_manager_unittest.cc
@@ -11,6 +11,7 @@
 #include "chrome/browser/extensions/extension_util.h"
 #include "extensions/browser/api/declarative_net_request/ruleset_matcher.h"
 #include "extensions/browser/api/declarative_net_request/test_utils.h"
+#include "extensions/browser/api/web_request/web_request_info.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
@@ -122,10 +123,13 @@ TEST_P(RulesetManagerTest, MultipleRulesets) {
 
   std::unique_ptr<net::URLRequest> request_one =
       GetRequestForURL("http://one.com");
+  WebRequestInfo request_one_info(request_one.get());
   std::unique_ptr<net::URLRequest> request_two =
       GetRequestForURL("http://two.com");
+  WebRequestInfo request_two_info(request_two.get());
   std::unique_ptr<net::URLRequest> request_three =
       GetRequestForURL("http://three.com");
+  WebRequestInfo request_three_info(request_three.get());
 
   // Test all possible combinations with |rule_one| and |rule_two| enabled.
   const bool is_incognito_context = false;
@@ -157,12 +161,14 @@ TEST_P(RulesetManagerTest, MultipleRulesets) {
 
     ASSERT_EQ(expected_matcher_count, manager->GetMatcherCountForTest());
 
-    EXPECT_EQ((mask & kEnableRulesetOne) != 0,
-              manager->ShouldBlockRequest(*request_one, is_incognito_context));
-    EXPECT_EQ((mask & kEnableRulesetTwo) != 0,
-              manager->ShouldBlockRequest(*request_two, is_incognito_context));
+    EXPECT_EQ(
+        (mask & kEnableRulesetOne) != 0,
+        manager->ShouldBlockRequest(request_one_info, is_incognito_context));
+    EXPECT_EQ(
+        (mask & kEnableRulesetTwo) != 0,
+        manager->ShouldBlockRequest(request_two_info, is_incognito_context));
     EXPECT_FALSE(
-        manager->ShouldBlockRequest(*request_three, is_incognito_context));
+        manager->ShouldBlockRequest(request_three_info, is_incognito_context));
 
     // Remove the rulesets.
     if (mask & kEnableRulesetOne)
@@ -188,15 +194,16 @@ TEST_P(RulesetManagerTest, IncognitoRequests) {
 
   std::unique_ptr<net::URLRequest> request =
       GetRequestForURL("http://example.com");
+  WebRequestInfo request_info(request.get());
 
   // By default, the extension is disabled in incognito mode. So requests from
   // incognito contexts should not be evaluated.
   EXPECT_FALSE(util::IsIncognitoEnabled(last_loaded_extension()->id(),
                                         browser_context()));
   EXPECT_FALSE(
-      manager->ShouldBlockRequest(*request, true /*is_incognito_context*/));
-  EXPECT_TRUE(
-      manager->ShouldBlockRequest(*request, false /*is_incognito_context*/));
+      manager->ShouldBlockRequest(request_info, true /*is_incognito_context*/));
+  EXPECT_TRUE(manager->ShouldBlockRequest(request_info,
+                                          false /*is_incognito_context*/));
 
   // Enabling the extension in incognito mode, should cause requests from
   // incognito contexts to also be evaluated.
@@ -204,9 +211,9 @@ TEST_P(RulesetManagerTest, IncognitoRequests) {
   EXPECT_TRUE(util::IsIncognitoEnabled(last_loaded_extension()->id(),
                                        browser_context()));
   EXPECT_TRUE(
-      manager->ShouldBlockRequest(*request, true /*is_incognito_context*/));
-  EXPECT_TRUE(
-      manager->ShouldBlockRequest(*request, false /*is_incognito_context*/));
+      manager->ShouldBlockRequest(request_info, true /*is_incognito_context*/));
+  EXPECT_TRUE(manager->ShouldBlockRequest(request_info,
+                                          false /*is_incognito_context*/));
 }
 
 // Test redirect rules.
@@ -229,14 +236,16 @@ TEST_P(RulesetManagerTest, Redirect) {
   GURL redirect_url;
   std::unique_ptr<net::URLRequest> request =
       GetRequestForURL("http://example.com");
-  EXPECT_TRUE(manager->ShouldRedirectRequest(*request, is_incognito_context,
-                                             &redirect_url));
+  extensions::WebRequestInfo request_info1(request.get());
+  EXPECT_TRUE(manager->ShouldRedirectRequest(
+      request_info1, is_incognito_context, &redirect_url));
   EXPECT_EQ(GURL("http://google.com"), redirect_url);
 
   // Ensure web-socket requests are not redirected.
   request = GetRequestForURL("ws://example.com");
-  EXPECT_FALSE(manager->ShouldRedirectRequest(*request, is_incognito_context,
-                                              &redirect_url));
+  extensions::WebRequestInfo request_info2(request.get());
+  EXPECT_FALSE(manager->ShouldRedirectRequest(
+      request_info2, is_incognito_context, &redirect_url));
 }
 
 INSTANTIATE_TEST_CASE_P(,
diff --git a/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_action_unittest.cc b/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_action_unittest.cc
index e5ecb2cf045..4b88dec5ca5 100644
--- a/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_action_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_action_unittest.cc
@@ -24,6 +24,7 @@
 #include "extensions/browser/api/declarative_webrequest/webrequest_condition.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
+#include "extensions/browser/api/web_request/web_request_info.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/common/extension.h"
 #include "net/base/request_priority.h"
@@ -152,8 +153,8 @@ bool WebRequestActionWithThreadsTest::ActionWorksOnRequest(
   std::list<LinkedPtrEventResponseDelta> deltas;
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(""));
-  WebRequestData request_data(regular_request.get(), stage, nullptr,
-                              headers.get());
+  WebRequestInfo request_info(regular_request.get());
+  WebRequestData request_data(&request_info, stage, headers.get());
   std::set<std::string> ignored_tags;
   WebRequestAction::ApplyInfo apply_info = { extension_info_map_.get(),
                                              request_data,
diff --git a/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_unittest.cc b/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_unittest.cc
index 8b7df22c693..9fd06229fb0 100644
--- a/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_unittest.cc
@@ -14,7 +14,6 @@
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/test/values_test_util.h"
@@ -25,6 +24,7 @@
 #include "extensions/browser/api/declarative/rules_registry_service.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
+#include "extensions/browser/api/web_request/web_request_info.h"
 #include "net/base/request_priority.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request.h"
@@ -102,18 +102,18 @@ class WebRequestRulesRegistryTest : public testing::Test {
   // Returns a rule that roughly matches http://*.example.com and
   // https://www.example.com and cancels it
   linked_ptr<api::events::Rule> CreateRule1() {
-    auto scheme_http = base::MakeUnique<base::ListValue>();
+    auto scheme_http = std::make_unique<base::ListValue>();
     scheme_http->AppendString("http");
-    auto http_condition_dict = base::MakeUnique<base::DictionaryValue>();
+    auto http_condition_dict = std::make_unique<base::DictionaryValue>();
     http_condition_dict->SetString(keys2::kHostSuffixKey, "example.com");
     base::DictionaryValue http_condition_url_filter;
     http_condition_url_filter.SetString(keys::kInstanceTypeKey,
                                         keys::kRequestMatcherType);
 
     scheme_http->AppendString("https");
-    auto https_condition_dict = base::MakeUnique<base::DictionaryValue>();
+    auto https_condition_dict = std::make_unique<base::DictionaryValue>();
     https_condition_dict->Set(keys2::kSchemesKey,
-                              base::MakeUnique<base::ListValue>());
+                              std::make_unique<base::ListValue>());
     https_condition_dict->SetString(keys2::kHostSuffixKey, "example.com");
     https_condition_dict->SetString(keys2::kHostPrefixKey, "www");
     base::DictionaryValue https_condition_url_filter;
@@ -174,7 +174,7 @@ class WebRequestRulesRegistryTest : public testing::Test {
   // contains index.html.
   linked_ptr<api::events::Rule> CreateIgnoreRule() {
     base::DictionaryValue condition_dict;
-    auto http_condition_dict = base::MakeUnique<base::DictionaryValue>();
+    auto http_condition_dict = std::make_unique<base::DictionaryValue>();
     http_condition_dict->SetString(keys2::kPathContainsKey, "index.html");
     condition_dict.SetString(keys::kInstanceTypeKey, keys::kRequestMatcherType);
     condition_dict.Set(keys::kUrlKey, std::move(http_condition_dict));
@@ -283,7 +283,8 @@ TEST_F(WebRequestRulesRegistryTest, AddRulesImpl) {
   net::TestURLRequestContext context;
   std::unique_ptr<net::URLRequest> http_request(context.CreateRequest(
       http_url, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data(http_request.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo http_request_info(http_request.get());
+  WebRequestData request_data(&http_request_info, ON_BEFORE_REQUEST);
   matches = registry->GetMatches(request_data);
   EXPECT_EQ(2u, matches.size());
 
@@ -299,7 +300,8 @@ TEST_F(WebRequestRulesRegistryTest, AddRulesImpl) {
   GURL foobar_url("http://www.foobar.com");
   std::unique_ptr<net::URLRequest> foobar_request(context.CreateRequest(
       foobar_url, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  request_data.request = foobar_request.get();
+  WebRequestInfo foobar_request_info(foobar_request.get());
+  request_data.request = &foobar_request_info;
   matches = registry->GetMatches(request_data);
   EXPECT_EQ(1u, matches.size());
   WebRequestRule::GlobalRuleId expected_pair =
@@ -426,7 +428,8 @@ TEST_F(WebRequestRulesRegistryTest, Precedences) {
   net::TestURLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       url, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo request_info(request.get());
+  WebRequestData request_data(&request_info, ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(NULL, request_data, false);
 
@@ -475,9 +478,10 @@ TEST_F(WebRequestRulesRegistryTest, Priorities) {
   net::TestURLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       url, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo request_info(request.get());
+  WebRequestData request_data(&request_info, ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
-      registry->CreateDeltas(NULL, request_data, false);
+      registry->CreateDeltas(nullptr, request_data, false);
 
   // The redirect by the first extension is ignored due to the ignore rule.
   ASSERT_EQ(1u, deltas.size());
@@ -549,7 +553,8 @@ TEST_F(WebRequestRulesRegistryTest, IgnoreRulesByTag) {
   net::TestURLRequestContext context;
   std::unique_ptr<net::URLRequest> request(context.CreateRequest(
       url, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data(request.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo request_info(request.get());
+  WebRequestData request_data(&request_info, ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
       registry->CreateDeltas(NULL, request_data, false);
 
@@ -599,7 +604,8 @@ TEST_F(WebRequestRulesRegistryTest, GetMatchesCheckFulfilled) {
   net::TestURLRequestContext context;
   std::unique_ptr<net::URLRequest> http_request(context.CreateRequest(
       http_url, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data(http_request.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo http_request_info(http_request.get());
+  WebRequestData request_data(&http_request_info, ON_BEFORE_REQUEST);
   matches = registry->GetMatches(request_data);
   EXPECT_EQ(1u, matches.size());
   WebRequestRule::GlobalRuleId expected_pair = std::make_pair(kExtensionId,
@@ -658,8 +664,9 @@ TEST_F(WebRequestRulesRegistryTest, GetMatchesDifferentUrls) {
     // Construct the inputs.
     std::unique_ptr<net::URLRequest> http_request(context.CreateRequest(
         urls[i], net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-    WebRequestData request_data(http_request.get(), ON_BEFORE_REQUEST);
     http_request->set_site_for_cookies(firstPartyUrls[i]);
+    WebRequestInfo http_request_info(http_request.get());
+    WebRequestData request_data(&http_request_info, ON_BEFORE_REQUEST);
     // Now run both rules on the input.
     matches = registry->GetMatches(request_data);
     SCOPED_TRACE(testing::Message("i = ") << i << ", rule id = "
@@ -807,7 +814,8 @@ TEST_F(WebRequestRulesRegistryTest, CheckOriginAndPathRegEx) {
   GURL url1("http://bar.com/index.html?foo.com");
   std::unique_ptr<net::URLRequest> request1(context.CreateRequest(
       url1, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data1(request1.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo request1_info(request1.get());
+  WebRequestData request_data1(&request1_info, ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data1, false);
   EXPECT_EQ(0u, deltas.size());
 
@@ -815,7 +823,8 @@ TEST_F(WebRequestRulesRegistryTest, CheckOriginAndPathRegEx) {
   GURL url2("http://foo.com/index.html");
   std::unique_ptr<net::URLRequest> request2(context.CreateRequest(
       url2, net::DEFAULT_PRIORITY, NULL, TRAFFIC_ANNOTATION_FOR_TESTS));
-  WebRequestData request_data2(request2.get(), ON_BEFORE_REQUEST);
+  WebRequestInfo request2_info(request2.get());
+  WebRequestData request_data2(&request2_info, ON_BEFORE_REQUEST);
   deltas = registry->CreateDeltas(NULL, request_data2, false);
   EXPECT_EQ(1u, deltas.size());
 }
diff --git a/chromium/chrome/browser/extensions/api/desktop_capture/desktop_capture_base.cc b/chromium/chrome/browser/extensions/api/desktop_capture/desktop_capture_base.cc
index 6086213cd0e..392ecad385f 100644
--- a/chromium/chrome/browser/extensions/api/desktop_capture/desktop_capture_base.cc
+++ b/chromium/chrome/browser/extensions/api/desktop_capture/desktop_capture_base.cc
@@ -4,11 +4,11 @@
 
 #include "chrome/browser/extensions/api/desktop_capture/desktop_capture_base.h"
 
+#include <memory>
 #include <tuple>
 #include <utility>
 
 #include "base/command_line.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
@@ -118,10 +118,10 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
               g_picker_factory->CreateMediaList(DesktopMediaID::TYPE_SCREEN);
         } else {
 #if defined(OS_CHROMEOS)
-          screen_list = base::MakeUnique<DesktopMediaListAsh>(
+          screen_list = std::make_unique<DesktopMediaListAsh>(
               DesktopMediaID::TYPE_SCREEN);
 #else   // !defined(OS_CHROMEOS)
-          screen_list = base::MakeUnique<NativeDesktopMediaList>(
+          screen_list = std::make_unique<NativeDesktopMediaList>(
               content::DesktopMediaID::TYPE_SCREEN,
               webrtc::DesktopCapturer::CreateScreenCapturer(
                   content::CreateDesktopCaptureOptions()));
@@ -141,7 +141,7 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
               g_picker_factory->CreateMediaList(DesktopMediaID::TYPE_WINDOW);
         } else {
 #if defined(OS_CHROMEOS)
-          window_list = base::MakeUnique<DesktopMediaListAsh>(
+          window_list = std::make_unique<DesktopMediaListAsh>(
               DesktopMediaID::TYPE_WINDOW);
 #else   // !defined(OS_CHROMEOS)
           // NativeDesktopMediaList calls the capturers on a background thread.
@@ -149,7 +149,7 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
           // windows) created here cannot share the same DesktopCaptureOptions
           // instance. DesktopCaptureOptions owns X connection, which cannot be
           // used on multiple threads concurrently.
-          window_list = base::MakeUnique<NativeDesktopMediaList>(
+          window_list = std::make_unique<NativeDesktopMediaList>(
               content::DesktopMediaID::TYPE_WINDOW,
               webrtc::DesktopCapturer::CreateWindowCapturer(
                   content::CreateDesktopCaptureOptions()));
@@ -170,7 +170,7 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
           tab_list = g_picker_factory->CreateMediaList(
               DesktopMediaID::TYPE_WEB_CONTENTS);
         } else {
-          tab_list = base::MakeUnique<TabDesktopMediaList>();
+          tab_list = std::make_unique<TabDesktopMediaList>();
         }
         have_tab_list = true;
         source_lists.push_back(std::move(tab_list));
diff --git a/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.cc b/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.cc
index a43f25b2bec..5070bed814f 100644
--- a/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.cc
@@ -5,13 +5,13 @@
 #include "chrome/browser/extensions/api/developer_private/developer_private_api.h"
 
 #include <stddef.h>
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ -60,6 +60,7 @@
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/content_verifier.h"
+#include "extensions/browser/disable_reason.h"
 #include "extensions/browser/error_map.h"
 #include "extensions/browser/extension_error.h"
 #include "extensions/browser/extension_prefs.h"
@@ -70,7 +71,6 @@
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/path_util.h"
 #include "extensions/browser/warning_service.h"
-#include "extensions/common/disable_reason.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/install_warning.h"
@@ -85,7 +85,6 @@
 #include "storage/browser/fileapi/file_system_operation_runner.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/text/bytes_formatting.h"
 
 namespace extensions {
 
@@ -587,9 +586,17 @@ ExtensionFunction::ResponseAction DeveloperPrivateAutoUpdateFunction::Run() {
     ExtensionUpdater::CheckParams params;
     params.fetch_priority = ManifestFetchData::FetchPriority::FOREGROUND;
     params.install_immediately = true;
+    // TODO(crbug.com/714018): Replace base::BindRepeating with base::BindOnce.
+    params.callback =
+        base::BindRepeating(&DeveloperPrivateAutoUpdateFunction::OnComplete,
+                            this /* ref counted */);
     updater->CheckNow(params);
   }
-  return RespondNow(NoArguments());
+  return RespondLater();
+}
+
+void DeveloperPrivateAutoUpdateFunction::OnComplete() {
+  Respond(NoArguments());
 }
 
 DeveloperPrivateGetExtensionsInfoFunction::
@@ -676,11 +683,8 @@ DeveloperPrivateGetExtensionSizeFunction::Run() {
   if (!extension)
     return RespondNow(Error(kNoSuchExtensionError));
 
-  // TODO(dpapad): Share this logic with
-  // chrome/browser/ui/views/apps/app_info_dialog/app_info_summary_panel.cc.
-  base::PostTaskWithTraitsAndReplyWithResult(
-      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
-      base::BindOnce(&base::ComputeDirectorySize, extension->path()),
+  extensions::path_util::CalculateAndFormatExtensionDirectorySize(
+      extension->path(), IDS_APPLICATION_INFO_SIZE_SMALL_LABEL,
       base::BindOnce(
           &DeveloperPrivateGetExtensionSizeFunction::OnSizeCalculated,
           this /* refcounted */));
@@ -689,17 +693,8 @@ DeveloperPrivateGetExtensionSizeFunction::Run() {
 }
 
 void DeveloperPrivateGetExtensionSizeFunction::OnSizeCalculated(
-    int64_t size_in_bytes) {
-  base::string16 response;
-
-  const int one_mebibyte_in_bytes = 1024 * 1024;
-  if (size_in_bytes < one_mebibyte_in_bytes) {
-    response = l10n_util::GetStringUTF16(IDS_APPLICATION_INFO_SIZE_SMALL_LABEL);
-  } else {
-    response =
-        ui::FormatBytesWithUnits(size_in_bytes, ui::DATA_UNITS_MEBIBYTE, true);
-  }
-  Respond(OneArgument(std::make_unique<base::Value>(response)));
+    const base::string16& size) {
+  Respond(OneArgument(std::make_unique<base::Value>(size)));
 }
 
 DeveloperPrivateGetItemsInfoFunction::DeveloperPrivateGetItemsInfoFunction() {}
@@ -736,7 +731,7 @@ DeveloperPrivateGetProfileConfigurationFunction::
 ExtensionFunction::ResponseAction
 DeveloperPrivateGetProfileConfigurationFunction::Run() {
   std::unique_ptr<developer::ProfileInfo> info =
-      CreateProfileInfo(GetProfile());
+      CreateProfileInfo(Profile::FromBrowserContext(browser_context()));
 
   // If this is called from the chrome://extensions page, we use this as a
   // heuristic that it's a good time to verify installs. We do this on startup,
@@ -759,9 +754,10 @@ DeveloperPrivateUpdateProfileConfigurationFunction::Run() {
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const developer::ProfileConfigurationUpdate& update = params->update;
-  PrefService* prefs = GetProfile()->GetPrefs();
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  PrefService* prefs = profile->GetPrefs();
   if (update.in_developer_mode) {
-    if (GetProfile()->IsSupervised())
+    if (profile->IsSupervised())
       return RespondNow(Error(kCannotUpdateSupervisedProfileSettingsError));
     prefs->SetBoolean(prefs::kExtensionsUIDeveloperMode,
                       *update.in_developer_mode);
@@ -864,7 +860,7 @@ ExtensionFunction::ResponseAction DeveloperPrivateReloadFunction::Run() {
   // Balanced in ClearObservers(), which is called from the first observer
   // method to be called with the appropriate extension (or shutdown).
   AddRef();
-  error_reporter_observer_.Add(ExtensionErrorReporter::GetInstance());
+  error_reporter_observer_.Add(LoadErrorReporter::GetInstance());
   registry_observer_.Add(ExtensionRegistry::Get(browser_context()));
 
   return RespondLater();
@@ -971,6 +967,21 @@ ExtensionFunction::ResponseAction DeveloperPrivateLoadUnpackedFunction::Run() {
   if (!web_contents)
     return RespondNow(Error(kCouldNotFindWebContentsError));
 
+  Profile* profile = Profile::FromBrowserContext(browser_context());
+  if (profile->IsSupervised()) {
+    return RespondNow(
+        Error("Supervised users cannot load unpacked extensions."));
+  }
+  PrefService* prefs = profile->GetPrefs();
+  if (!prefs->GetBoolean(prefs::kExtensionsUIDeveloperMode)) {
+    return RespondNow(
+        Error("Must be in developer mode to load unpacked extensions."));
+  }
+  if (ExtensionManagementFactory::GetForBrowserContext(browser_context())
+          ->BlacklistedByDefault()) {
+    return RespondNow(Error("Extension installation is blocked by policy."));
+  }
+
   fail_quietly_ = params->options &&
                   params->options->fail_quietly &&
                   *params->options->fail_quietly;
@@ -1189,7 +1200,7 @@ ExtensionFunction::ResponseAction DeveloperPrivatePackDirectoryFunction::Run() {
   AddRef();  // Balanced in OnPackSuccess / OnPackFailure.
 
   pack_job_ =
-      base::MakeUnique<PackExtensionJob>(this, root_directory, key_file, flags);
+      std::make_unique<PackExtensionJob>(this, root_directory, key_file, flags);
   pack_job_->Start();
   return RespondLater();
 }
@@ -1213,7 +1224,7 @@ bool DeveloperPrivateLoadDirectoryFunction::RunAsync() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &directory_url_str));
 
   context_ = content::BrowserContext::GetStoragePartition(
-                 GetProfile(), render_frame_host()->GetSiteInstance())
+                 browser_context(), render_frame_host()->GetSiteInstance())
                  ->GetFileSystemContext();
 
   // Directory url is non empty only for syncfilesystem.
@@ -1280,7 +1291,7 @@ bool DeveloperPrivateLoadDirectoryFunction::LoadByFileSystemAPI(
   project_name = directory_url_str.substr(pos + 1);
   project_base_url_ = directory_url_str.substr(0, pos + 1);
 
-  base::FilePath project_path(GetProfile()->GetPath());
+  base::FilePath project_path(browser_context()->GetPath());
   project_path = project_path.AppendASCII(kUnpackedAppsFolder);
   project_path = project_path.Append(
       base::FilePath::FromUTF8Unsafe(project_name));
@@ -1297,12 +1308,12 @@ bool DeveloperPrivateLoadDirectoryFunction::LoadByFileSystemAPI(
 }
 
 void DeveloperPrivateLoadDirectoryFunction::Load() {
-  ExtensionService* service = GetExtensionService(GetProfile());
+  ExtensionService* service = GetExtensionService(browser_context());
   UnpackedInstaller::Create(service)->Load(project_base_path_);
 
   // TODO(grv) : The unpacked installer should fire an event when complete
   // and return the extension_id.
-  SetResult(base::MakeUnique<base::Value>("-1"));
+  SetResult(std::make_unique<base::Value>("-1"));
   SendResponse(true);
 }
 
@@ -1475,7 +1486,7 @@ ExtensionFunction::ResponseAction DeveloperPrivateChoosePathFunction::Run() {
 
 void DeveloperPrivateChoosePathFunction::FileSelected(
     const base::FilePath& path) {
-  Respond(OneArgument(base::MakeUnique<base::Value>(path.LossyDisplayName())));
+  Respond(OneArgument(std::make_unique<base::Value>(path.LossyDisplayName())));
   Release();
 }
 
@@ -1490,7 +1501,7 @@ DeveloperPrivateChoosePathFunction::~DeveloperPrivateChoosePathFunction() {}
 
 ExtensionFunction::ResponseAction
 DeveloperPrivateIsProfileManagedFunction::Run() {
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(
+  return RespondNow(OneArgument(std::make_unique<base::Value>(
       Profile::FromBrowserContext(browser_context())->IsSupervised())));
 }
 
@@ -1589,7 +1600,7 @@ DeveloperPrivateOpenDevToolsFunction::Run() {
     if (!extension)
       return RespondNow(Error(kNoSuchExtensionError));
 
-    Profile* profile = GetProfile();
+    Profile* profile = Profile::FromBrowserContext(browser_context());
     if (properties.incognito && *properties.incognito)
       profile = profile->GetOffTheRecordProfile();
 
@@ -1652,7 +1663,7 @@ DeveloperPrivateDeleteExtensionErrorsFunction::Run() {
   const developer::DeleteExtensionErrorsProperties& properties =
       params->properties;
 
-  ErrorConsole* error_console = ErrorConsole::Get(GetProfile());
+  ErrorConsole* error_console = ErrorConsole::Get(browser_context());
   int type = -1;
   if (properties.type != developer::ERROR_TYPE_NONE) {
     type = properties.type == developer::ERROR_TYPE_MANIFEST ?
@@ -1753,8 +1764,9 @@ ExtensionFunction::ResponseAction DeveloperPrivateShowPathFunction::Run() {
 
   // We explicitly show manifest.json in order to work around an issue in OSX
   // where opening the directory doesn't focus the Finder.
-  platform_util::ShowItemInFolder(GetProfile(),
-                                  extension->path().Append(kManifestFilename));
+  platform_util::ShowItemInFolder(
+      Profile::FromBrowserContext(browser_context()),
+      extension->path().Append(kManifestFilename));
   return RespondNow(NoArguments());
 }
 
@@ -1766,8 +1778,8 @@ DeveloperPrivateSetShortcutHandlingSuspendedFunction::Run() {
   std::unique_ptr<developer::SetShortcutHandlingSuspended::Params> params(
       developer::SetShortcutHandlingSuspended::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
-  ExtensionCommandsGlobalRegistry::Get(GetProfile())->
-      SetShortcutHandlingSuspended(params->is_suspended);
+  ExtensionCommandsGlobalRegistry::Get(browser_context())
+      ->SetShortcutHandlingSuspended(params->is_suspended);
   return RespondNow(NoArguments());
 }
 
@@ -1781,7 +1793,7 @@ DeveloperPrivateUpdateExtensionCommandFunction::Run() {
   EXTENSION_FUNCTION_VALIDATE(params);
   const developer::ExtensionCommandUpdate& update = params->update;
 
-  CommandService* command_service = CommandService::Get(GetProfile());
+  CommandService* command_service = CommandService::Get(browser_context());
 
   if (update.scope != developer::COMMAND_SCOPE_NONE) {
     command_service->SetScope(update.extension_id, update.command_name,
diff --git a/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.h b/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.h
index f7e768cc6f2..6a82e8f416d 100644
--- a/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.h
+++ b/chromium/chrome/browser/extensions/api/developer_private/developer_private_api.h
@@ -16,9 +16,9 @@
 #include "chrome/browser/extensions/api/developer_private/entry_picker.h"
 #include "chrome/browser/extensions/chrome_extension_function.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
-#include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_management.h"
 #include "chrome/browser/extensions/extension_uninstall_dialog.h"
+#include "chrome/browser/extensions/load_error_reporter.h"
 #include "chrome/browser/extensions/pack_extension_job.h"
 #include "chrome/common/extensions/api/developer_private.h"
 #include "chrome/common/extensions/webstore_install_result.h"
@@ -27,6 +27,7 @@
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_prefs_observer.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/process_manager_observer.h"
@@ -268,7 +269,7 @@ class DeveloperPrivateAPI : public BrowserContextKeyedAPI,
 
 namespace api {
 
-class DeveloperPrivateAPIFunction : public ChromeUIThreadExtensionFunction {
+class DeveloperPrivateAPIFunction : public UIThreadExtensionFunction {
  protected:
   ~DeveloperPrivateAPIFunction() override;
 
@@ -289,6 +290,9 @@ class DeveloperPrivateAutoUpdateFunction : public DeveloperPrivateAPIFunction {
  protected:
   ~DeveloperPrivateAutoUpdateFunction() override;
   ResponseAction Run() override;
+
+ private:
+  void OnComplete();
 };
 
 class DeveloperPrivateGetItemsInfoFunction
@@ -359,7 +363,7 @@ class DeveloperPrivateGetExtensionSizeFunction
   ~DeveloperPrivateGetExtensionSizeFunction() override;
   ResponseAction Run() override;
 
-  void OnSizeCalculated(int64_t size_in_bytes);
+  void OnSizeCalculated(const base::string16& size);
 
   DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateGetExtensionSizeFunction);
 };
@@ -399,7 +403,7 @@ class DeveloperPrivateUpdateExtensionConfigurationFunction
 
 class DeveloperPrivateReloadFunction : public DeveloperPrivateAPIFunction,
                                        public ExtensionRegistryObserver,
-                                       public ExtensionErrorReporter::Observer {
+                                       public LoadErrorReporter::Observer {
  public:
   DECLARE_EXTENSION_FUNCTION("developerPrivate.reload",
                              DEVELOPERPRIVATE_RELOAD);
@@ -411,7 +415,7 @@ class DeveloperPrivateReloadFunction : public DeveloperPrivateAPIFunction,
                          const Extension* extension) override;
   void OnShutdown(ExtensionRegistry* registry) override;
 
-  // ExtensionErrorReporter::Observer:
+  // LoadErrorReporter::Observer:
   void OnLoadFailure(content::BrowserContext* browser_context,
                      const base::FilePath& file_path,
                      const std::string& error) override;
@@ -437,7 +441,7 @@ class DeveloperPrivateReloadFunction : public DeveloperPrivateAPIFunction,
 
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       registry_observer_;
-  ScopedObserver<ExtensionErrorReporter, ExtensionErrorReporter::Observer>
+  ScopedObserver<LoadErrorReporter, LoadErrorReporter::Observer>
       error_reporter_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateReloadFunction);
diff --git a/chromium/chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc b/chromium/chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc
index 5113fec8fd4..dfa6519275e 100644
--- a/chromium/chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/developer_private/developer_private_api_unittest.cc
@@ -9,13 +9,14 @@
 
 #include "base/files/file_util.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/scoped_observer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/chrome_test_extension_loader.h"
 #include "chrome/browser/extensions/error_console/error_console.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "chrome/browser/extensions/extension_management.h"
+#include "chrome/browser/extensions/extension_management_test_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_with_install.h"
 #include "chrome/browser/extensions/extension_util.h"
@@ -27,6 +28,7 @@
 #include "chrome/common/extensions/api/developer_private.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/test_browser_window.h"
+#include "chrome/test/base/testing_profile.h"
 #include "components/crx_file/id_util.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
@@ -64,12 +66,12 @@ namespace {
 const char kGoodCrx[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 
 std::unique_ptr<KeyedService> BuildAPI(content::BrowserContext* context) {
-  return base::MakeUnique<DeveloperPrivateAPI>(context);
+  return std::make_unique<DeveloperPrivateAPI>(context);
 }
 
 std::unique_ptr<KeyedService> BuildEventRouter(
     content::BrowserContext* profile) {
-  return base::MakeUnique<EventRouter>(profile, ExtensionPrefs::Get(profile));
+  return std::make_unique<EventRouter>(profile, ExtensionPrefs::Get(profile));
 }
 
 bool HasAllUrlsPermission(const Extension* extension,
@@ -131,6 +133,8 @@ class DeveloperPrivateApiUnitTest : public ExtensionServiceTestWithInstall {
   void GetProfileConfiguration(
       std::unique_ptr<api::developer_private::ProfileInfo>* profile_info);
 
+  virtual bool ProfileIsSupervised() const { return false; }
+
   Browser* browser() { return browser_.get(); }
 
  private:
@@ -165,7 +169,7 @@ const Extension* DeveloperPrivateApiUnitTest::LoadUnpackedExtension() {
       " \"permissions\": [\"*://*/*\"]"
       "}";
 
-  test_extension_dirs_.push_back(base::MakeUnique<TestExtensionDir>());
+  test_extension_dirs_.push_back(std::make_unique<TestExtensionDir>());
   TestExtensionDir* dir = test_extension_dirs_.back().get();
   dir->WriteManifest(kManifest);
 
@@ -218,7 +222,7 @@ void DeveloperPrivateApiUnitTest::TestExtensionPrefSetting(
   EXPECT_FALSE(has_pref.Run()) << key;
 
   {
-    auto parameters = base::MakeUnique<base::DictionaryValue>();
+    auto parameters = std::make_unique<base::DictionaryValue>();
     parameters->SetString("extensionId", extension_id);
     parameters->SetBoolean(key, true);
 
@@ -239,7 +243,7 @@ void DeveloperPrivateApiUnitTest::TestExtensionPrefSetting(
   }
 
   {
-    auto parameters = base::MakeUnique<base::DictionaryValue>();
+    auto parameters = std::make_unique<base::DictionaryValue>();
     parameters->SetString("extensionId", extension_id);
     parameters->SetBoolean(key, false);
 
@@ -320,6 +324,7 @@ void DeveloperPrivateApiUnitTest::SetUp() {
   // - see BuildTestingProfile in extension_service_test_base.cc.
   ExtensionServiceInitParams init_params = CreateDefaultInitParams();
   init_params.pref_file.clear();
+  init_params.profile_is_supervised = ProfileIsSupervised();
   InitializeExtensionService(init_params);
 
   browser_window_.reset(new TestBrowserWindow());
@@ -334,6 +339,10 @@ void DeveloperPrivateApiUnitTest::SetUp() {
 
   DeveloperPrivateAPI::GetFactoryInstance()->SetTestingFactory(
       profile(), &BuildAPI);
+
+  // Loading unpacked extensions through the developerPrivate API requires
+  // developer mode to be enabled.
+  profile()->GetPrefs()->SetBoolean(prefs::kExtensionsUIDeveloperMode, true);
 }
 
 void DeveloperPrivateApiUnitTest::TearDown() {
@@ -1097,7 +1106,7 @@ TEST_F(DeveloperPrivateApiUnitTest, RepairPolicyExtension) {
 
   // Set up a mock provider with a policy extension.
   std::unique_ptr<MockExternalProvider> mock_provider =
-      base::MakeUnique<MockExternalProvider>(
+      std::make_unique<MockExternalProvider>(
           service(), Manifest::EXTERNAL_POLICY_DOWNLOAD);
   MockExternalProvider* mock_provider_ptr = mock_provider.get();
   AddMockExternalProvider(std::move(mock_provider));
@@ -1133,7 +1142,7 @@ TEST_F(DeveloperPrivateApiUnitTest, RepairPolicyExtension) {
 // when DeveloperToolsDisabled policy is active.
 TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateDevModeDisabledPolicy) {
   testing_pref_service()->SetManagedPref(prefs::kExtensionsUIDeveloperMode,
-                                         base::MakeUnique<base::Value>(false));
+                                         std::make_unique<base::Value>(false));
 
   UpdateProfileConfigurationDevMode(true);
 
@@ -1149,18 +1158,98 @@ TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateDevModeDisabledPolicy) {
 // Test developerPrivate.updateProfileConfiguration: Try to turn on devMode
 // (without DeveloperToolsDisabled policy).
 TEST_F(DeveloperPrivateApiUnitTest, DeveloperPrivateDevMode) {
+  UpdateProfileConfigurationDevMode(false);
   EXPECT_FALSE(
       profile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode));
+  {
+    std::unique_ptr<api::developer_private::ProfileInfo> profile_info;
+    ASSERT_NO_FATAL_FAILURE(GetProfileConfiguration(&profile_info));
+    EXPECT_FALSE(profile_info->in_developer_mode);
+    EXPECT_FALSE(profile_info->is_developer_mode_controlled_by_policy);
+  }
 
   UpdateProfileConfigurationDevMode(true);
-
   EXPECT_TRUE(
       profile()->GetPrefs()->GetBoolean(prefs::kExtensionsUIDeveloperMode));
+  {
+    std::unique_ptr<api::developer_private::ProfileInfo> profile_info;
+    ASSERT_NO_FATAL_FAILURE(GetProfileConfiguration(&profile_info));
+    EXPECT_TRUE(profile_info->in_developer_mode);
+    EXPECT_FALSE(profile_info->is_developer_mode_controlled_by_policy);
+  }
+}
 
-  std::unique_ptr<api::developer_private::ProfileInfo> profile_info;
-  ASSERT_NO_FATAL_FAILURE(GetProfileConfiguration(&profile_info));
-  EXPECT_TRUE(profile_info->in_developer_mode);
-  EXPECT_FALSE(profile_info->is_developer_mode_controlled_by_policy);
+TEST_F(DeveloperPrivateApiUnitTest, LoadUnpackedFailsWithoutDevMode) {
+  std::unique_ptr<content::WebContents> web_contents(
+      content::WebContentsTester::CreateTestWebContents(profile(), nullptr));
+
+  base::FilePath path = data_dir().AppendASCII("good_unpacked");
+  api::EntryPicker::SkipPickerAndAlwaysSelectPathForTest(&path);
+
+  PrefService* prefs = profile()->GetPrefs();
+  prefs->SetBoolean(prefs::kExtensionsUIDeveloperMode, false);
+  scoped_refptr<UIThreadExtensionFunction> function =
+      base::MakeRefCounted<api::DeveloperPrivateLoadUnpackedFunction>();
+  function->SetRenderFrameHost(web_contents->GetMainFrame());
+  std::string error = extension_function_test_utils::RunFunctionAndReturnError(
+      function.get(), "[]", browser());
+  EXPECT_THAT(error, testing::HasSubstr("developer mode"));
+  prefs->SetBoolean(prefs::kExtensionsUIDeveloperMode, true);
+}
+
+TEST_F(DeveloperPrivateApiUnitTest, LoadUnpackedFailsWithBlacklistingPolicy) {
+  std::unique_ptr<content::WebContents> web_contents(
+      content::WebContentsTester::CreateTestWebContents(profile(), nullptr));
+
+  base::FilePath path = data_dir().AppendASCII("good_unpacked");
+  api::EntryPicker::SkipPickerAndAlwaysSelectPathForTest(&path);
+
+  {
+    ExtensionManagementPrefUpdater<sync_preferences::TestingPrefServiceSyncable>
+        pref_updater(testing_profile()->GetTestingPrefService());
+    pref_updater.SetBlacklistedByDefault(true);
+  }
+  EXPECT_TRUE(
+      ExtensionManagementFactory::GetForBrowserContext(browser_context())
+          ->BlacklistedByDefault());
+
+  scoped_refptr<UIThreadExtensionFunction> function =
+      base::MakeRefCounted<api::DeveloperPrivateLoadUnpackedFunction>();
+  function->SetRenderFrameHost(web_contents->GetMainFrame());
+  std::string error = extension_function_test_utils::RunFunctionAndReturnError(
+      function.get(), "[]", browser());
+  EXPECT_THAT(error, testing::HasSubstr("policy"));
+}
+
+class DeveloperPrivateApiSupervisedUserUnitTest
+    : public DeveloperPrivateApiUnitTest {
+ public:
+  DeveloperPrivateApiSupervisedUserUnitTest() = default;
+  ~DeveloperPrivateApiSupervisedUserUnitTest() override = default;
+
+  bool ProfileIsSupervised() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeveloperPrivateApiSupervisedUserUnitTest);
+};
+
+// Tests trying to call loadUnpacked when the profile shouldn't be allowed to.
+TEST_F(DeveloperPrivateApiSupervisedUserUnitTest,
+       LoadUnpackedFailsForSupervisedUsers) {
+  std::unique_ptr<content::WebContents> web_contents(
+      content::WebContentsTester::CreateTestWebContents(profile(), nullptr));
+
+  base::FilePath path = data_dir().AppendASCII("good_unpacked");
+  api::EntryPicker::SkipPickerAndAlwaysSelectPathForTest(&path);
+
+  ASSERT_TRUE(profile()->IsSupervised());
+
+  scoped_refptr<UIThreadExtensionFunction> function =
+      base::MakeRefCounted<api::DeveloperPrivateLoadUnpackedFunction>();
+  function->SetRenderFrameHost(web_contents->GetMainFrame());
+  std::string error = extension_function_test_utils::RunFunctionAndReturnError(
+      function.get(), "[]", browser());
+  EXPECT_THAT(error, testing::HasSubstr("Supervised"));
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator.cc b/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator.cc
index 32e39d4a7b8..53965e17392 100644
--- a/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator.cc
+++ b/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator.cc
@@ -139,6 +139,7 @@ developer::RuntimeError ConstructRuntimeError(const RuntimeError& error) {
     default:
       NOTREACHED();
   }
+  result.context_url = error.context_url().spec();
   result.occurrences = error.occurrences();
   // NOTE(devlin): This is called "render_view_id" in the api for legacy
   // reasons, but it's not a high priority to change.
diff --git a/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc b/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc
index 92c7d2b0152..8eb8f33bd4f 100644
--- a/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/developer_private/extension_info_generator_unittest.cc
@@ -244,12 +244,13 @@ TEST_F(ExtensionInfoGeneratorUnitTest, BasicInfoTest) {
           .Build();
   service()->AddExtension(extension.get());
   ErrorConsole* error_console = ErrorConsole::Get(profile());
+  const GURL kContextUrl("http://example.com");
   error_console->ReportError(base::WrapUnique(new RuntimeError(
       extension->id(), false, base::UTF8ToUTF16("source"),
       base::UTF8ToUTF16("message"),
       StackTrace(1, StackFrame(1, 1, base::UTF8ToUTF16("source"),
                                base::UTF8ToUTF16("function"))),
-      GURL("url"), logging::LOG_ERROR, 1, 1)));
+      kContextUrl, logging::LOG_ERROR, 1, 1)));
   error_console->ReportError(base::WrapUnique(
       new ManifestError(extension->id(), base::UTF8ToUTF16("message"),
                         base::UTF8ToUTF16("key"), base::string16())));
@@ -258,7 +259,7 @@ TEST_F(ExtensionInfoGeneratorUnitTest, BasicInfoTest) {
       base::UTF8ToUTF16("message"),
       StackTrace(1, StackFrame(1, 1, base::UTF8ToUTF16("source"),
                                base::UTF8ToUTF16("function"))),
-      GURL("url"), logging::LOG_VERBOSE, 1, 1)));
+      kContextUrl, logging::LOG_VERBOSE, 1, 1)));
 
   // It's not feasible to validate every field here, because that would be
   // a duplication of the logic in the method itself. Instead, test a handful
@@ -301,6 +302,7 @@ TEST_F(ExtensionInfoGeneratorUnitTest, BasicInfoTest) {
   EXPECT_EQ(api::developer_private::ERROR_TYPE_RUNTIME, runtime_error.type);
   EXPECT_EQ(api::developer_private::ERROR_LEVEL_ERROR,
             runtime_error.severity);
+  EXPECT_EQ(kContextUrl, GURL(runtime_error.context_url));
   EXPECT_EQ(1u, runtime_error.stack_trace.size());
   ASSERT_EQ(1u, info->manifest_errors.size());
   const api::developer_private::RuntimeError& runtime_error_verbose =
diff --git a/chromium/chrome/browser/extensions/api/developer_private/inspectable_views_finder.cc b/chromium/chrome/browser/extensions/api/developer_private/inspectable_views_finder.cc
index 73578c61774..ce8ad64b783 100644
--- a/chromium/chrome/browser/extensions/api/developer_private/inspectable_views_finder.cc
+++ b/chromium/chrome/browser/extensions/api/developer_private/inspectable_views_finder.cc
@@ -70,9 +70,6 @@ InspectableViewsFinder::View InspectableViewsFinder::ConstructView(
     case VIEW_TYPE_EXTENSION_POPUP:
       view.type = api::developer_private::VIEW_TYPE_EXTENSION_POPUP;
       break;
-    case VIEW_TYPE_LAUNCHER_PAGE:
-      view.type = api::developer_private::VIEW_TYPE_LAUNCHER_PAGE;
-      break;
     case VIEW_TYPE_PANEL:
       view.type = api::developer_private::VIEW_TYPE_PANEL;
       break;
diff --git a/chromium/chrome/browser/extensions/api/device_permissions_manager_unittest.cc b/chromium/chrome/browser/extensions/api/device_permissions_manager_unittest.cc
index 85440fe1744..e77604705a4 100644
--- a/chromium/chrome/browser/extensions/api/device_permissions_manager_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/device_permissions_manager_unittest.cc
@@ -4,6 +4,8 @@
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
@@ -42,7 +44,7 @@ class FakeHidDeviceManager : public HidDeviceManager {
 
 std::unique_ptr<KeyedService> CreateHidDeviceManager(
     content::BrowserContext* context) {
-  return base::MakeUnique<FakeHidDeviceManager>(context);
+  return std::make_unique<FakeHidDeviceManager>(context);
 }
 
 }  // namespace
diff --git a/chromium/chrome/browser/extensions/api/dial/dial_api.cc b/chromium/chrome/browser/extensions/api/dial/dial_api.cc
index 1dd4d5883bd..a5922dc9eed 100644
--- a/chromium/chrome/browser/extensions/api/dial/dial_api.cc
+++ b/chromium/chrome/browser/extensions/api/dial/dial_api.cc
@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/dial/dial_api_factory.h"
@@ -184,9 +183,9 @@ void DialAPI::ShutdownOnUIThread() {
 void DialAPI::SetDeviceForTest(
     const media_router::DialDeviceData& device_data,
     const media_router::DialDeviceDescriptionData& device_description) {
-  test_device_data_ = base::MakeUnique<DialDeviceData>(device_data);
+  test_device_data_ = std::make_unique<DialDeviceData>(device_data);
   test_device_description_ =
-      base::MakeUnique<DialDeviceDescriptionData>(device_description);
+      std::make_unique<DialDeviceDescriptionData>(device_description);
 }
 
 DialDiscoverNowFunction::DialDiscoverNowFunction()
@@ -207,7 +206,7 @@ void DialDiscoverNowFunction::Work() {
 
 bool DialDiscoverNowFunction::Respond() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  SetResult(base::MakeUnique<base::Value>(result_));
+  SetResult(std::make_unique<base::Value>(result_));
   return true;
 }
 
@@ -255,7 +254,7 @@ void DialFetchDeviceDescriptionFunction::MaybeStartFetch(const GURL& url) {
     return;
   }
 
-  device_description_fetcher_ = base::MakeUnique<DeviceDescriptionFetcher>(
+  device_description_fetcher_ = std::make_unique<DeviceDescriptionFetcher>(
       url, Profile::FromBrowserContext(browser_context())->GetRequestContext(),
       base::BindOnce(&DialFetchDeviceDescriptionFunction::OnFetchComplete,
                      this),
diff --git a/chromium/chrome/browser/extensions/api/downloads/downloads_api.cc b/chromium/chrome/browser/extensions/api/downloads/downloads_api.cc
index 2502d572a81..e4fd3fb38a5 100644
--- a/chromium/chrome/browser/extensions/api/downloads/downloads_api.cc
+++ b/chromium/chrome/browser/extensions/api/downloads/downloads_api.cc
@@ -1089,11 +1089,11 @@ bool DownloadsDownloadFunction::RunAsync() {
       creator_suggested_filename, options.conflict_action));
   // Prevent login prompts for 401/407 responses.
   download_params->set_do_not_prompt_for_login(true);
+  download_params->set_download_source(content::DownloadSource::EXTENSION_API);
 
   DownloadManager* manager = BrowserContext::GetDownloadManager(
       current_profile);
   manager->DownloadUrl(std::move(download_params));
-  RecordDownloadSource(DOWNLOAD_INITIATED_BY_EXTENSION);
   RecordApiFunctions(DOWNLOADS_FUNCTION_DOWNLOAD);
   return true;
 }
@@ -1107,7 +1107,7 @@ void DownloadsDownloadFunction::OnStarted(
   VLOG(1) << __func__ << " " << item << " " << interrupt_reason;
   if (item) {
     DCHECK_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
-    SetResult(base::MakeUnique<base::Value>(static_cast<int>(item->GetId())));
+    SetResult(std::make_unique<base::Value>(static_cast<int>(item->GetId())));
     if (!creator_suggested_filename.empty() ||
         (creator_conflict_action !=
          downloads::FILENAME_CONFLICT_ACTION_UNIQUIFY)) {
@@ -1581,7 +1581,7 @@ void DownloadsGetFileIconFunction::OnIconURLExtracted(const std::string& url) {
     return;
   }
   RecordApiFunctions(DOWNLOADS_FUNCTION_GET_FILE_ICON);
-  SetResult(base::MakeUnique<base::Value>(url));
+  SetResult(std::make_unique<base::Value>(url));
   SendResponse(true);
 }
 
@@ -1921,7 +1921,7 @@ void ExtensionDownloadsEventRouter::OnDownloadRemoved(
   DispatchEvent(
       events::DOWNLOADS_ON_ERASED, downloads::OnErased::kEventName, true,
       Event::WillDispatchCallback(),
-      base::MakeUnique<base::Value>(static_cast<int>(download_item->GetId())));
+      std::make_unique<base::Value>(static_cast<int>(download_item->GetId())));
 }
 
 void ExtensionDownloadsEventRouter::DispatchEvent(
@@ -1949,7 +1949,7 @@ void ExtensionDownloadsEventRouter::DispatchEvent(
   Profile* restrict_to_browser_context =
       (include_incognito && !profile_->IsOffTheRecord()) ? nullptr : profile_;
   auto event =
-      base::MakeUnique<Event>(histogram_value, event_name, std::move(args),
+      std::make_unique<Event>(histogram_value, event_name, std::move(args),
                               restrict_to_browser_context);
   event->will_dispatch_callback = will_dispatch_callback;
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
diff --git a/chromium/chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc b/chromium/chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc
index d133a69aeb3..ee607987815 100644
--- a/chromium/chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc
@@ -3,8 +3,6 @@
 // found in the LICENSE file.
 
 // Disable everything on windows only. http://crbug.com/306144
-#ifndef OS_WIN
-
 #include <stddef.h>
 #include <stdint.h>
 
@@ -20,6 +18,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/bind_test_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/download_core_service.h"
@@ -48,12 +47,14 @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
+#include "content/public/test/controllable_http_response.h"
 #include "content/public/test/download_test_observer.h"
-#include "content/public/test/test_download_request_handler.h"
+#include "content/public/test/test_download_http_response.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/notification_types.h"
 #include "net/base/data_url.h"
+#include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/url_request/url_request_slow_download_job.h"
 #include "net/url_request/url_request.h"
@@ -78,6 +79,10 @@ namespace downloads = api::downloads;
 
 namespace {
 
+const char kFirstDownloadUrl[] = "/download1";
+const char kSecondDownloadUrl[] = "/download2";
+const int kDownloadSize = 1024 * 10;
+
 // Comparator that orders download items by their ID. Can be used with
 // std::sort.
 struct DownloadIdComparator {
@@ -323,6 +328,13 @@ class DownloadExtensionTest : public ExtensionApiTest {
     // Disable file chooser for current profile.
     DownloadTestFileActivityObserver observer(current_browser()->profile());
     observer.EnableFileChooser(false);
+
+    first_download_ = std::make_unique<content::ControllableHttpResponse>(
+        embedded_test_server(), kFirstDownloadUrl);
+    second_download_ = std::make_unique<content::ControllableHttpResponse>(
+        embedded_test_server(), kSecondDownloadUrl);
+
+    host_resolver()->AddRule("*", "127.0.0.1");
   }
 
   void GoOnTheRecord() { current_browser_ = browser(); }
@@ -442,60 +454,71 @@ class DownloadExtensionTest : public ExtensionApiTest {
     return true;
   }
 
-  void CreateSlowTestDownloads(
-      size_t count, DownloadManager::DownloadVector* items) {
-    for (size_t i = 0; i < count; ++i) {
-      std::unique_ptr<content::DownloadTestObserver> observer(
-          CreateInProgressDownloadObserver(1));
-      GURL slow_download_url(net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
-      ui_test_utils::NavigateToURL(current_browser(), slow_download_url);
-      observer->WaitForFinished();
-      EXPECT_EQ(
-          1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
-    }
+  void CreateTwoDownloads(DownloadManager::DownloadVector* items) {
+    CreateFirstSlowTestDownload();
+    CreateSecondSlowTestDownload();
+
     GetCurrentManager()->GetAllDownloads(items);
-    ASSERT_EQ(count, items->size());
+    ASSERT_EQ(2u, items->size());
   }
 
-  DownloadItem* CreateSlowTestDownload() {
-    std::unique_ptr<content::DownloadTestObserver> observer(
-        CreateInProgressDownloadObserver(1));
-    GURL slow_download_url(net::URLRequestSlowDownloadJob::kUnknownSizeUrl);
+  DownloadItem* CreateFirstSlowTestDownload() {
     DownloadManager* manager = GetCurrentManager();
 
     EXPECT_EQ(0, manager->NonMaliciousInProgressCount());
     EXPECT_EQ(0, manager->InProgressCount());
     if (manager->InProgressCount() != 0)
       return NULL;
+    return CreateSlowTestDownload(first_download_.get(), kFirstDownloadUrl);
+  }
 
-    ui_test_utils::NavigateToURL(current_browser(), slow_download_url);
+  DownloadItem* CreateSecondSlowTestDownload() {
+    return CreateSlowTestDownload(second_download_.get(), kSecondDownloadUrl);
+  }
+
+  DownloadItem* CreateSlowTestDownload(
+      content::ControllableHttpResponse* response,
+      const std::string& path) {
+    if (!embedded_test_server()->Started())
+      StartEmbeddedTestServer();
+    std::unique_ptr<content::DownloadTestObserver> observer(
+        CreateInProgressDownloadObserver(1));
+    DownloadManager* manager = GetCurrentManager();
+
+    const GURL url = embedded_test_server()->GetURL(path);
+    ui_test_utils::NavigateToURLWithDisposition(
+        current_browser(), url, WindowOpenDisposition::CURRENT_TAB,
+        ui_test_utils::BROWSER_TEST_NONE);
+
+    response->WaitForRequest();
+    response->Send(
+        "HTTP/1.1 200 OK\r\n"
+        "Content-type: application/octet-stream\r\n"
+        "Cache-Control: max-age=0\r\n"
+        "\r\n");
+    response->Send(std::string(kDownloadSize, '*'));
 
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::IN_PROGRESS));
 
     DownloadManager::DownloadVector items;
     manager->GetAllDownloads(&items);
+    EXPECT_TRUE(!items.empty());
+    return items.back();
+  }
 
-    DownloadItem* new_item = NULL;
-    for (DownloadManager::DownloadVector::iterator iter = items.begin();
-         iter != items.end(); ++iter) {
-      if ((*iter)->GetState() == DownloadItem::IN_PROGRESS) {
-        // There should be only one IN_PROGRESS item.
-        EXPECT_EQ(NULL, new_item);
-        new_item = *iter;
-      }
-    }
-    return new_item;
+  void FinishFirstSlowDownloads() {
+    FinishSlowDownloads(first_download_.get());
   }
 
-  void FinishPendingSlowDownloads() {
+  void FinishSecondSlowDownloads() {
+    FinishSlowDownloads(second_download_.get());
+  }
+
+  void FinishSlowDownloads(content::ControllableHttpResponse* response) {
     std::unique_ptr<content::DownloadTestObserver> observer(
         CreateDownloadObserver(1));
-    GURL finish_url(net::URLRequestSlowDownloadJob::kFinishDownloadUrl);
-    ui_test_utils::NavigateToURLWithDisposition(
-        current_browser(), finish_url,
-        WindowOpenDisposition::NEW_FOREGROUND_TAB,
-        ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
+    response->Done();
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   }
@@ -596,6 +619,9 @@ class DownloadExtensionTest : public ExtensionApiTest {
   Browser* current_browser_;
   std::unique_ptr<DownloadsEventsListener> events_listener_;
 
+  std::unique_ptr<content::ControllableHttpResponse> first_download_;
+  std::unique_ptr<content::ControllableHttpResponse> second_download_;
+
   DISALLOW_COPY_AND_ASSIGN(DownloadExtensionTest);
 };
 
@@ -808,7 +834,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                    open_function,
                    "[-42]").c_str());
 
-  DownloadItem* download_item = CreateSlowTestDownload();
+  DownloadItem* download_item = CreateFirstSlowTestDownload();
   ASSERT_TRUE(download_item);
   EXPECT_FALSE(download_item->GetOpened());
   EXPECT_FALSE(download_item->GetOpenWhenComplete());
@@ -827,7 +853,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                    open_function,
                    DownloadItemIdAsArgList(download_item)).c_str());
 
-  FinishPendingSlowDownloads();
+  FinishFirstSlowDownloads();
   EXPECT_FALSE(download_item->GetOpened());
 
   open_function = new DownloadsOpenFunction();
@@ -846,7 +872,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_PauseResumeCancelErase) {
-  DownloadItem* download_item = CreateSlowTestDownload();
+  DownloadItem* download_item = CreateFirstSlowTestDownload();
   ASSERT_TRUE(download_item);
   std::string error;
 
@@ -954,7 +980,7 @@ scoped_refptr<UIThreadExtensionFunction> MockedGetFileIconFunction(
 // download items.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
     MAYBE_DownloadExtensionTest_FileIcon_Active) {
-  DownloadItem* download_item = CreateSlowTestDownload();
+  DownloadItem* download_item = CreateFirstSlowTestDownload();
   ASSERT_TRUE(download_item);
   ASSERT_FALSE(download_item->GetTargetFilePath().empty());
   std::string args32(base::StringPrintf("[%d, {\"size\": 32}]",
@@ -980,7 +1006,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
       args32, &result_string));
 
   // Finish the download and try again.
-  FinishPendingSlowDownloads();
+  FinishFirstSlowDownloads();
   EXPECT_EQ(DownloadItem::COMPLETE, download_item->GetState());
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
@@ -990,9 +1016,10 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
       args32, &result_string));
+  download_item->Remove();
 
   // Now create another download.
-  download_item = CreateSlowTestDownload();
+  download_item = CreateSecondSlowTestDownload();
   ASSERT_TRUE(download_item);
   ASSERT_FALSE(download_item->GetTargetFilePath().empty());
   args32 = base::StringPrintf("[%d, {\"size\": 32}]", download_item->GetId());
@@ -1074,7 +1101,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 // Test passing the empty query to search().
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_SearchEmptyQuery) {
-  ScopedCancellingItem item(CreateSlowTestDownload());
+  ScopedCancellingItem item(CreateFirstSlowTestDownload());
   ASSERT_TRUE(item.get());
 
   std::unique_ptr<base::Value> result(
@@ -1088,7 +1115,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 #if !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadsShowFunction) {
-  ScopedCancellingItem item(CreateSlowTestDownload());
+  ScopedCancellingItem item(CreateFirstSlowTestDownload());
   ASSERT_TRUE(item.get());
 
   RunFunction(new DownloadsShowFunction(), DownloadItemIdAsArgList(item.get()));
@@ -1096,7 +1123,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadsShowDefaultFolderFunction) {
-  ScopedCancellingItem item(CreateSlowTestDownload());
+  ScopedCancellingItem item(CreateFirstSlowTestDownload());
   ASSERT_TRUE(item.get());
 
   RunFunction(new DownloadsShowDefaultFolderFunction(),
@@ -1105,7 +1132,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadsDragFunction) {
-  ScopedCancellingItem item(CreateSlowTestDownload());
+  ScopedCancellingItem item(CreateFirstSlowTestDownload());
   ASSERT_TRUE(item.get());
 
   RunFunction(new DownloadsDragFunction(), DownloadItemIdAsArgList(item.get()));
@@ -1152,7 +1179,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        MAYBE_DownloadExtensionTest_SearchId) {
   DownloadManager::DownloadVector items;
-  CreateSlowTestDownloads(2, &items);
+  CreateTwoDownloads(&items);
   ScopedItemVectorCanceller delete_items(&items);
 
   std::unique_ptr<base::Value> result(RunFunctionAndReturnResult(
@@ -1180,7 +1207,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        MAYBE_DownloadExtensionTest_SearchIdAndFilename) {
   DownloadManager::DownloadVector items;
-  CreateSlowTestDownloads(2, &items);
+  CreateTwoDownloads(&items);
   ScopedItemVectorCanceller delete_items(&items);
 
   std::unique_ptr<base::Value> result(
@@ -1296,7 +1323,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        MAYBE_DownloadExtensionTest_SearchState) {
   DownloadManager::DownloadVector items;
-  CreateSlowTestDownloads(2, &items);
+  CreateTwoDownloads(&items);
   ScopedItemVectorCanceller delete_items(&items);
 
   items[0]->Cancel(true);
@@ -1320,7 +1347,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        MAYBE_DownloadExtensionTest_SearchLimit) {
   DownloadManager::DownloadVector items;
-  CreateSlowTestDownloads(2, &items);
+  CreateTwoDownloads(&items);
   ScopedItemVectorCanceller delete_items(&items);
 
   std::unique_ptr<base::Value> result(RunFunctionAndReturnResult(
@@ -1405,12 +1432,12 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
   // items total instead of 2.
   // TODO(benjhayden): Figure out where the third item comes from.
   GoOffTheRecord();
-  DownloadItem* off_item = CreateSlowTestDownload();
+  DownloadItem* off_item = CreateFirstSlowTestDownload();
   ASSERT_TRUE(off_item);
   off_item_arg = DownloadItemIdAsArgList(off_item);
 
   GoOnTheRecord();
-  DownloadItem* on_item = CreateSlowTestDownload();
+  DownloadItem* on_item = CreateSecondSlowTestDownload();
   ASSERT_TRUE(on_item);
   on_item_arg = DownloadItemIdAsArgList(on_item);
   ASSERT_TRUE(on_item->GetTargetFilePath() != off_item->GetTargetFilePath());
@@ -1660,14 +1687,71 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                           result_id)));
 }
 
+namespace {
+
+class CustomResponse : public net::test_server::HttpResponse {
+ public:
+  CustomResponse(net::test_server::SendCompleteCallback* callback,
+                 base::TaskRunner** task_runner,
+                 bool first_request)
+      : callback_(callback),
+        task_runner_(task_runner),
+        first_request_(first_request) {}
+  ~CustomResponse() override {}
+
+  void SendResponse(
+      const net::test_server::SendBytesCallback& send,
+      const net::test_server::SendCompleteCallback& done) override {
+    std::string response(
+        "HTTP/1.1 200 OK\r\n"
+        "Content-type: application/octet-stream\r\n"
+        "Cache-Control: max-age=0\r\n"
+        "\r\n");
+    response += std::string(kDownloadSize, '*');
+
+    if (first_request_) {
+      *callback_ = std::move(done);
+      *task_runner_ = base::MessageLoop::current()->task_runner().get();
+      send.Run(response, base::BindRepeating([]() {}));
+    } else {
+      send.Run(response, std::move(done));
+    }
+  }
+
+ private:
+  net::test_server::SendCompleteCallback* callback_;
+  base::TaskRunner** task_runner_;
+  bool first_request_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomResponse);
+};
+
+}  // namespace
+
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_InterruptAndResume) {
   LoadExtension("downloads_split");
-  content::TestDownloadRequestHandler download_request_handler;
-  download_request_handler.StartServing(
-      content::TestDownloadRequestHandler::Parameters::
-          WithSingleInterruption());
-  GURL download_url = download_request_handler.url();
+
+  DownloadItem* item = nullptr;
+
+  net::test_server::SendCompleteCallback complete_callback;
+  base::TaskRunner* embedded_test_server_io_runner = nullptr;
+  const char kThirdDownloadUrl[] = "/download3";
+  bool first_request = true;
+  embedded_test_server()->RegisterRequestHandler(base::BindLambdaForTesting(
+      [&](const net::test_server::HttpRequest& request) {
+        std::unique_ptr<net::test_server::HttpResponse> rv;
+        if (request.relative_url == kThirdDownloadUrl) {
+          rv = std::make_unique<CustomResponse>(&complete_callback,
+                                                &embedded_test_server_io_runner,
+                                                first_request);
+          first_request = false;
+        }
+        return rv;
+      }));
+
+  StartEmbeddedTestServer();
+  const GURL download_url = embedded_test_server()->GetURL(kThirdDownloadUrl);
 
   // Start downloading a file.
   std::unique_ptr<base::Value> result(RunFunctionAndReturnResult(
@@ -1676,12 +1760,16 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
   ASSERT_TRUE(result.get());
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
-  DownloadItem* item = GetCurrentManager()->GetDownload(result_id);
+  item = GetCurrentManager()->GetDownload(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl());
   EXPECT_EQ(GetExtensionURL(), item->GetSiteUrl().spec());
 
+  item->SimulateErrorForTesting(
+      content::DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
+  embedded_test_server_io_runner->PostTask(FROM_HERE, complete_callback);
+
   ASSERT_TRUE(WaitFor(downloads::OnChanged::kEventName,
                       base::StringPrintf("[{\"id\":%d,"
                                          "  \"state\": {"
@@ -4127,7 +4215,7 @@ IN_PROC_BROWSER_TEST_F(
                           item->GetId())));
 
   ClearEvents();
-  FinishPendingSlowDownloads();
+  FinishFirstSlowDownloads();
 
   // The download should complete successfully.
   ASSERT_TRUE(WaitFor(downloads::OnChanged::kEventName,
@@ -4308,5 +4396,3 @@ TEST(ExtensionDetermineDownloadFilenameInternal,
 }
 
 }  // namespace extensions
-
-#endif  // http://crbug.com/306144
diff --git a/chromium/chrome/browser/extensions/api/downloads/downloads_api_unittest.cc b/chromium/chrome/browser/extensions/api/downloads/downloads_api_unittest.cc
index 1351c633fe4..af2fc33b4ed 100644
--- a/chromium/chrome/browser/extensions/api/downloads/downloads_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/downloads/downloads_api_unittest.cc
@@ -5,7 +5,6 @@
 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/download/download_core_service_factory.h"
 #include "chrome/browser/download/download_core_service_impl.h"
 #include "chrome/browser/download/download_history.h"
@@ -117,7 +116,7 @@ class DownloadsApiUnitTest : public ExtensionApiUnittest {
 std::unique_ptr<KeyedService>
 DownloadsApiUnitTest::TestingDownloadCoreServiceFactory(
     content::BrowserContext* browser_context) {
-  return base::MakeUnique<TestDownloadCoreService>(
+  return std::make_unique<TestDownloadCoreService>(
       Profile::FromBrowserContext(browser_context));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.cc b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.cc
index dd893701588..7f41f2d8534 100644
--- a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.cc
@@ -11,7 +11,6 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
@@ -703,7 +702,7 @@ bool EasyUnlockPrivateGetRemoteDevicesFunction::RunAsync() {
     const base::ListValue* devices =
         EasyUnlockService::Get(profile)->GetRemoteDevices();
     SetResult(devices ? devices->CreateDeepCopy()
-                      : base::MakeUnique<base::ListValue>());
+                      : std::make_unique<base::ListValue>());
     SendResponse(true);
   }
 
diff --git a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api_chromeos_unittest.cc b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api_chromeos_unittest.cc
index 1c1aa455057..290b81d3093 100644
--- a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api_chromeos_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api_chromeos_unittest.cc
@@ -11,7 +11,6 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
@@ -33,6 +32,7 @@
 #include "extensions/browser/test_event_router.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
+#include "ui/aura/env.h"
 
 namespace {
 
@@ -130,9 +130,11 @@ class EasyUnlockPrivateApiTest : public extensions::ExtensionApiUnittest {
         proximity_auth::switches::kDisableBluetoothLowEnergyDiscovery);
 
     chromeos::DBusThreadManager::Initialize();
-    bluez::BluezDBusManager::Initialize(
-        chromeos::DBusThreadManager::Get()->GetSystemBus(),
-        chromeos::DBusThreadManager::Get()->IsUsingFakes());
+    if (aura::Env::GetInstance()->mode() == aura::Env::Mode::LOCAL) {
+      bluez::BluezDBusManager::Initialize(
+          chromeos::DBusThreadManager::Get()->GetSystemBus(),
+          chromeos::DBusThreadManager::Get()->IsUsingFakes());
+    }
     client_ = chromeos::DBusThreadManager::Get()->GetEasyUnlockClient();
 
     extensions::ExtensionApiUnittest::SetUp();
@@ -141,7 +143,8 @@ class EasyUnlockPrivateApiTest : public extensions::ExtensionApiUnittest {
   void TearDown() override {
     extensions::ExtensionApiUnittest::TearDown();
 
-    bluez::BluezDBusManager::Shutdown();
+    if (aura::Env::GetInstance()->mode() == aura::Env::Mode::LOCAL)
+      bluez::BluezDBusManager::Shutdown();
     chromeos::DBusThreadManager::Shutdown();
   }
 
@@ -257,7 +260,7 @@ TEST_F(EasyUnlockPrivateApiTest, CreateSecureMessage) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("PAYLOAD"));
   args->Append(StringToBinaryValue("KEY"));
-  auto options = base::MakeUnique<base::DictionaryValue>();
+  auto options = std::make_unique<base::DictionaryValue>();
   options->Set("associatedData", StringToBinaryValue("ASSOCIATED_DATA"));
   options->Set("publicMetadata", StringToBinaryValue("PUBLIC_METADATA"));
   options->Set("verificationKeyId",
@@ -299,7 +302,7 @@ TEST_F(EasyUnlockPrivateApiTest, CreateSecureMessage_EmptyOptions) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("PAYLOAD"));
   args->Append(StringToBinaryValue("KEY"));
-  auto options = base::MakeUnique<base::DictionaryValue>();
+  auto options = std::make_unique<base::DictionaryValue>();
   args->Append(std::move(options));
 
   ASSERT_TRUE(extension_function_test_utils::RunFunction(
@@ -331,7 +334,7 @@ TEST_F(EasyUnlockPrivateApiTest, CreateSecureMessage_AsymmetricSign) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("PAYLOAD"));
   args->Append(StringToBinaryValue("KEY"));
-  auto options = base::MakeUnique<base::DictionaryValue>();
+  auto options = std::make_unique<base::DictionaryValue>();
   options->Set("associatedData",
                StringToBinaryValue("ASSOCIATED_DATA"));
   options->Set("verificationKeyId",
@@ -369,7 +372,7 @@ TEST_F(EasyUnlockPrivateApiTest, UnwrapSecureMessage) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("MESSAGE"));
   args->Append(StringToBinaryValue("KEY"));
-  auto options = base::MakeUnique<base::DictionaryValue>();
+  auto options = std::make_unique<base::DictionaryValue>();
   options->Set("associatedData", StringToBinaryValue("ASSOCIATED_DATA"));
   options->SetString(
       "encryptType",
@@ -406,7 +409,7 @@ TEST_F(EasyUnlockPrivateApiTest, UnwrapSecureMessage_EmptyOptions) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("MESSAGE"));
   args->Append(StringToBinaryValue("KEY"));
-  auto options = base::MakeUnique<base::DictionaryValue>();
+  auto options = std::make_unique<base::DictionaryValue>();
   args->Append(std::move(options));
 
   ASSERT_TRUE(extension_function_test_utils::RunFunction(
@@ -437,7 +440,7 @@ TEST_F(EasyUnlockPrivateApiTest, UnwrapSecureMessage_AsymmetricSign) {
   std::unique_ptr<base::ListValue> args(new base::ListValue);
   args->Append(StringToBinaryValue("MESSAGE"));
   args->Append(StringToBinaryValue("KEY"));
-  auto options = base::MakeUnique<base::DictionaryValue>();
+  auto options = std::make_unique<base::DictionaryValue>();
   options->Set("associatedData",
                StringToBinaryValue("ASSOCIATED_DATA"));
   options->SetString(
diff --git a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection_manager.cc b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection_manager.cc
index 421f4f19cc4..0ca60a93f09 100644
--- a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection_manager.cc
+++ b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection_manager.cc
@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection.h"
 #include "chrome/common/extensions/api/easy_unlock_private.h"
 #include "components/cryptauth/connection.h"
@@ -102,7 +101,7 @@ bool EasyUnlockPrivateConnectionManager::SendMessage(
     const std::string& message_body) {
   Connection* connection = GetConnection(extension->id(), connection_id);
   if (connection && connection->IsConnected()) {
-    connection->SendMessage(base::MakeUnique<WireMessage>(message_body));
+    connection->SendMessage(std::make_unique<WireMessage>(message_body));
     return true;
   }
   return false;
@@ -172,7 +171,7 @@ void EasyUnlockPrivateConnectionManager::DispatchConnectionEvent(
     std::unique_ptr<base::ListValue> args_copy(args->DeepCopy());
     int connection_index = 0;
     args_copy->Set(connection_index,
-                   base::MakeUnique<base::Value>(connection_id));
+                   std::make_unique<base::Value>(connection_id));
     std::unique_ptr<Event> event(
         new Event(histogram_value, event_name, std::move(args_copy)));
     EventRouter::Get(browser_context_)
diff --git a/chromium/chrome/browser/extensions/api/enterprise_device_attributes/enterprise_device_attributes_apitest.cc b/chromium/chrome/browser/extensions/api/enterprise_device_attributes/enterprise_device_attributes_apitest.cc
index a83c867240c..b4422a1d396 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_device_attributes/enterprise_device_attributes_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/enterprise_device_attributes/enterprise_device_attributes_apitest.cc
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/affiliation_test_helper.h"
@@ -98,7 +99,7 @@ class EnterpriseDeviceAttributesTest :
 
     // Set up fake install attributes.
     std::unique_ptr<chromeos::StubInstallAttributes> attributes =
-        base::MakeUnique<chromeos::StubInstallAttributes>();
+        std::make_unique<chromeos::StubInstallAttributes>();
 
     attributes->SetCloudManaged("fake-domain", "fake-id");
     policy::BrowserPolicyConnectorChromeOS::SetInstallAttributesForTesting(
diff --git a/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc b/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc
index d20974aad2d..38502bd20a8 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc
+++ b/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api.cc
@@ -16,6 +16,7 @@
 #include "chrome/common/extensions/api/enterprise_platform_keys_internal.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/cert/x509_certificate.h"
+#include "net/cert/x509_util.h"
 
 namespace extensions {
 
@@ -117,10 +118,10 @@ void EnterprisePlatformKeysGetCertificatesFunction::OnGotCertificates(
   for (net::CertificateList::const_iterator it = certs->begin();
        it != certs->end();
        ++it) {
-    std::string der_encoding;
-    net::X509Certificate::GetDEREncoded((*it)->os_cert_handle(), &der_encoding);
-    client_certs->Append(base::Value::CreateWithCopiedBuffer(
-        der_encoding.data(), der_encoding.size()));
+    base::StringPiece cert_der =
+        net::x509_util::CryptoBufferAsStringPiece((*it)->cert_buffer());
+    client_certs->Append(std::make_unique<base::Value>(
+        base::Value::BlobStorage(cert_der.begin(), cert_der.end())));
   }
 
   std::unique_ptr<base::ListValue> results(new base::ListValue());
diff --git a/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api_unittest.cc b/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api_unittest.cc
index c077c99b2fc..6ca6aa5a0ef 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_api_unittest.cc
@@ -109,7 +109,9 @@ void GetCertificateCallbackTrue(
     const chromeos::attestation::AttestationFlow::CertificateCallback&
         callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(callback, true, "certificate"));
+      FROM_HERE,
+      base::BindOnce(callback, chromeos::attestation::ATTESTATION_SUCCESS,
+                     "certificate"));
 }
 
 void GetCertificateCallbackFalse(
@@ -120,7 +122,10 @@ void GetCertificateCallbackFalse(
     const chromeos::attestation::AttestationFlow::CertificateCallback&
         callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(callback, false, ""));
+      FROM_HERE,
+      base::BindOnce(callback,
+                     chromeos::attestation::ATTESTATION_UNSPECIFIED_FAILURE,
+                     ""));
 }
 
 class EPKChallengeKeyTestBase : public BrowserWithTestWindowTest {
@@ -235,11 +240,11 @@ class EPKChallengeMachineKeyTest : public EPKChallengeKeyTestBase {
   }
 
   std::unique_ptr<base::ListValue> CreateArgsNoRegister() {
-    return CreateArgsInternal(base::MakeUnique<bool>(false));
+    return CreateArgsInternal(std::make_unique<bool>(false));
   }
 
   std::unique_ptr<base::ListValue> CreateArgsRegister() {
-    return CreateArgsInternal(base::MakeUnique<bool>(true));
+    return CreateArgsInternal(std::make_unique<bool>(true));
   }
 
   std::unique_ptr<base::ListValue> CreateArgsInternal(
diff --git a/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_apitest_nss.cc b/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_apitest_nss.cc
index a3661f06641..5dc16a22ef2 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_apitest_nss.cc
+++ b/chromium/chrome/browser/extensions/api/enterprise_platform_keys/enterprise_platform_keys_apitest_nss.cc
@@ -8,47 +8,19 @@
 #include <memory>
 
 #include "base/macros.h"
-#include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/chromeos/login/test/https_forwarder.h"
-#include "chrome/browser/chromeos/login/ui/login_display_host.h"
-#include "chrome/browser/chromeos/policy/affiliation_test_helper.h"
-#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
-#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/api/platform_keys/platform_keys_test_base.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/net/url_request_mock_util.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/test/base/ui_test_utils.h"
-#include "chromeos/chromeos_switches.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "chromeos/dbus/fake_session_manager_client.h"
-#include "chromeos/dbus/session_manager_client.h"
-#include "components/policy/core/browser/browser_policy_connector.h"
-#include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/policy_constants.h"
-#include "components/prefs/pref_service.h"
-#include "components/signin/core/account_id/account_id.h"
-#include "components/user_manager/user_manager.h"
 #include "content/public/common/content_switches.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_test_system_nss_key_slot.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/test_extension_registry_observer.h"
-#include "extensions/browser/test_extension_registry_observer.h"
-#include "extensions/test/result_catcher.h"
-#include "google_apis/gaia/fake_gaia.h"
-#include "google_apis/gaia/gaia_constants.h"
-#include "google_apis/gaia/gaia_switches.h"
-#include "google_apis/gaia/gaia_urls.h"
-#include "net/base/net_errors.h"
 #include "net/cert/nss_cert_database.h"
-#include "net/dns/mock_host_resolver.h"
-#include "net/test/embedded_test_server/embedded_test_server.h"
-#include "net/test/embedded_test_server/http_request.h"
-#include "net/test/embedded_test_server/http_response.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -159,186 +131,35 @@ void ImportPrivateKeyPKCS8ToSlot(const unsigned char* pkcs8_der,
 // its extension ID is well-known and the policy system can push policies for
 // the extension.
 const char kTestExtensionID[] = "aecpbnckhoppanpmefllkdkohionpmig";
-const char kAffiliationID[] = "some-affiliation-id";
-const char kTestUserinfoToken[] = "fake-userinfo-token";
-
-using policy::affiliation_test_helper::kEnterpriseUserEmail;
-using policy::affiliation_test_helper::kEnterpriseUserGaiaId;
-
-enum SystemToken {
-  SYSTEM_TOKEN_EXISTS,
-  SYSTEM_TOKEN_NOT_EXISTS
-};
-
-enum DeviceStatus {
-  DEVICE_STATUS_ENROLLED,
-  DEVICE_STATUS_NOT_ENROLLED
-};
-
-enum UserAffiliation {
-  USER_AFFILIATION_ENROLLED_DOMAIN,
-  USER_AFFILIATION_UNRELATED
-};
 
 struct Params {
-  Params(SystemToken system_token,
-         DeviceStatus device_status,
-         UserAffiliation user_affiliation)
-      : system_token_(system_token),
-        device_status_(device_status),
-        user_affiliation_(user_affiliation) {}
-
-  SystemToken system_token_;
-  DeviceStatus device_status_;
-  UserAffiliation user_affiliation_;
+  Params(PlatformKeysTestBase::SystemTokenStatus system_token_status,
+         PlatformKeysTestBase::EnrollmentStatus enrollment_status,
+         PlatformKeysTestBase::UserStatus user_status)
+      : system_token_status_(system_token_status),
+        enrollment_status_(enrollment_status),
+        user_status_(user_status) {}
+
+  PlatformKeysTestBase::SystemTokenStatus system_token_status_;
+  PlatformKeysTestBase::EnrollmentStatus enrollment_status_;
+  PlatformKeysTestBase::UserStatus user_status_;
 };
 
 class EnterprisePlatformKeysTest
-    : public ExtensionApiTest,
+    : public PlatformKeysTestBase,
       public ::testing::WithParamInterface<Params> {
  public:
   EnterprisePlatformKeysTest()
-      : account_id_(AccountId::FromUserEmailGaiaId(kEnterpriseUserEmail,
-                                                   kEnterpriseUserGaiaId)) {
-    // Command line should not be tweaked as if user is already logged in.
-    set_chromeos_user_ = false;
-    // We log in without running browser.
-    set_exit_when_last_browser_closes(false);
-  }
-
-  void SetUp() override {
-    base::FilePath test_data_dir;
-    PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
-    embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
-
-    embedded_test_server()->RegisterRequestHandler(
-        base::Bind(&FakeGaia::HandleRequest,
-                   base::Unretained(&fake_gaia_)));
-
-    // Don't spin up the IO thread yet since no threads are allowed while
-    // spawning sandbox host process. See crbug.com/322732.
-    ASSERT_TRUE(embedded_test_server()->InitializeAndListen());
-
-    // Start https wrapper here so that the URLs can be pointed at it in
-    // SetUpCommandLine().
-    ASSERT_TRUE(gaia_https_forwarder_.Initialize(
-        GaiaUrls::GetInstance()->gaia_url().host(),
-        embedded_test_server()->base_url()));
-
-    ExtensionApiTest::SetUp();
-  }
+      : PlatformKeysTestBase(GetParam().system_token_status_,
+                             GetParam().enrollment_status_,
+                             GetParam().user_status_) {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
-    ExtensionApiTest::SetUpCommandLine(command_line);
+    PlatformKeysTestBase::SetUpCommandLine(command_line);
 
     // Enable the WebCrypto API.
     command_line->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
-
-    policy::affiliation_test_helper::
-      AppendCommandLineSwitchesForLoginManager(command_line);
-
-    const GURL gaia_url = gaia_https_forwarder_.GetURLForSSLHost(std::string());
-    command_line->AppendSwitchASCII(::switches::kGaiaUrl, gaia_url.spec());
-    command_line->AppendSwitchASCII(::switches::kLsoUrl, gaia_url.spec());
-    command_line->AppendSwitchASCII(::switches::kGoogleApisUrl,
-                                    gaia_url.spec());
-
-    fake_gaia_.Initialize();
-    fake_gaia_.set_issue_oauth_code_cookie(true);
-  }
-
-  void SetUpInProcessBrowserTestFixture() override {
-    ExtensionApiTest::SetUpInProcessBrowserTestFixture();
-
-    chromeos::FakeSessionManagerClient* fake_session_manager_client =
-        new chromeos::FakeSessionManagerClient;
-    chromeos::DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
-        std::unique_ptr<chromeos::SessionManagerClient>(
-            fake_session_manager_client));
-
-    if (GetParam().device_status_ == DEVICE_STATUS_ENROLLED) {
-      std::set<std::string> device_affiliation_ids;
-      device_affiliation_ids.insert(kAffiliationID);
-      policy::affiliation_test_helper::SetDeviceAffiliationID(
-          &device_policy_test_helper_, fake_session_manager_client,
-          device_affiliation_ids);
-    }
-
-
-    if (GetParam().user_affiliation_ == USER_AFFILIATION_ENROLLED_DOMAIN) {
-      std::set<std::string> user_affiliation_ids;
-      user_affiliation_ids.insert(kAffiliationID);
-      policy::UserPolicyBuilder user_policy;
-      policy::affiliation_test_helper::SetUserAffiliationIDs(
-          &user_policy, fake_session_manager_client, account_id_.GetUserEmail(),
-          user_affiliation_ids);
-    }
-
-
-    EXPECT_CALL(policy_provider_, IsInitializationComplete(testing::_))
-        .WillRepeatedly(testing::Return(true));
-    policy_provider_.SetAutoRefresh();
-    policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
-        &policy_provider_);
-  }
-
-  void SetUpOnMainThread() override {
-    host_resolver()->AddRule("*", "127.0.0.1");
-    // Start the accept thread as the sandbox host process has already been
-    // spawned.
-    embedded_test_server()->StartAcceptingConnections();
-
-    FakeGaia::AccessTokenInfo token_info;
-    token_info.scopes.insert(GaiaConstants::kDeviceManagementServiceOAuth);
-    token_info.scopes.insert(GaiaConstants::kOAuthWrapBridgeUserInfoScope);
-    token_info.audience = GaiaUrls::GetInstance()->oauth2_chrome_client_id();
-    token_info.token = kTestUserinfoToken;
-    token_info.email = account_id_.GetUserEmail();
-    fake_gaia_.IssueOAuthToken(
-        policy::affiliation_test_helper::kFakeRefreshToken,
-        token_info);
-
-    // On PRE_ test stage list of users is empty at this point. Then in the body
-    // of PRE_ test kEnterpriseUser is added. Afterwards in the main test flow
-    // after PRE_ test the list of user contains one kEnterpriseUser user.
-    // This user logs in.
-    const base::ListValue* users =
-        g_browser_process->local_state()->GetList("LoggedInUsers");
-
-    // This condition is not held in PRE_ test.
-    if (!users->empty())
-      policy::affiliation_test_helper::LoginUser(account_id_);
-
-    if (GetParam().system_token_ == SYSTEM_TOKEN_EXISTS) {
-      base::RunLoop loop;
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO, FROM_HERE,
-          base::BindOnce(&EnterprisePlatformKeysTest::SetUpTestSystemSlotOnIO,
-                         base::Unretained(this), loop.QuitClosure()));
-      loop.Run();
-    }
-
-    ExtensionApiTest::SetUpOnMainThread();
-  }
-
-  void TearDownOnMainThread() override {
-    ExtensionApiTest::TearDownOnMainThread();
-
-    if (chromeos::LoginDisplayHost::default_host())
-      chromeos::LoginDisplayHost::default_host()->Finalize(base::OnceClosure());
-    base::RunLoop().RunUntilIdle();
-
-    if (GetParam().system_token_ == SYSTEM_TOKEN_EXISTS) {
-      base::RunLoop loop;
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO, FROM_HERE,
-          base::BindOnce(
-              &EnterprisePlatformKeysTest::TearDownTestSystemSlotOnIO,
-              base::Unretained(this), loop.QuitClosure()));
-      loop.Run();
-    }
-    EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
   }
 
   void DidGetCertDatabase(const base::Closure& done_callback,
@@ -372,71 +193,27 @@ class EnterprisePlatformKeysTest
     // Set the policy and wait until the extension is installed.
     extensions::TestExtensionRegistryObserver observer(
         extensions::ExtensionRegistry::Get(profile()));
-    policy_provider_.UpdateChromePolicy(policy);
+    mock_policy_provider()->UpdateChromePolicy(policy);
     observer.WaitForExtensionWillBeInstalled();
   }
 
-  // Load |page_url| in |browser| and wait for PASSED or FAILED notification.
-  // The functionality of this function is reduced functionality of
-  // RunExtensionSubtest(), but we don't use it here because it requires
-  // function InProcessBrowserTest::browser() to return non-NULL pointer.
-  // Unfortunately it returns the value which is set in constructor and can't be
-  // modified. Because on login flow there is no browser, the function
-  // InProcessBrowserTest::browser() always returns NULL. Besides this we need
-  // only very little functionality from RunExtensionSubtest(). Thus so that
-  // don't make RunExtensionSubtest() to complex we just introduce a new
-  // function.
-  bool TestExtension(Browser* browser, const std::string& page_url) {
-    DCHECK(!page_url.empty()) << "page_url cannot be empty";
-
-    extensions::ResultCatcher catcher;
-    ui_test_utils::NavigateToURL(browser, GURL(page_url));
-
-    if (!catcher.GetNextResult()) {
-      message_ = catcher.message();
-      return false;
-    }
-    return true;
-  }
-
  private:
-
-  void SetUpTestSystemSlotOnIO(const base::Closure& done_callback) {
-    test_system_slot_.reset(new crypto::ScopedTestSystemNSSKeySlot());
-    ASSERT_TRUE(test_system_slot_->ConstructedSuccessfully());
-
+  void PrepareTestSystemSlotOnIO(
+      crypto::ScopedTestSystemNSSKeySlot* system_slot) override {
     // Import a private key to the system slot.  The Javascript part of this
     // test has a prepared certificate for this key.
     ImportPrivateKeyPKCS8ToSlot(privateKeyPkcs8System,
                                 arraysize(privateKeyPkcs8System),
-                                test_system_slot_->slot());
-
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE, done_callback);
-  }
-
-  void TearDownTestSystemSlotOnIO(const base::Closure& done_callback) {
-    test_system_slot_.reset();
-
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE, done_callback);
+                                system_slot->slot());
   }
 
- protected:
-  const AccountId account_id_;
-
- private:
-  policy::DevicePolicyCrosTestHelper device_policy_test_helper_;
-  std::unique_ptr<crypto::ScopedTestSystemNSSKeySlot> test_system_slot_;
-  policy::MockConfigurationPolicyProvider policy_provider_;
-  FakeGaia fake_gaia_;
-  chromeos::HTTPSForwarder gaia_https_forwarder_;
+  DISALLOW_COPY_AND_ASSIGN(EnterprisePlatformKeysTest);
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_P(EnterprisePlatformKeysTest, PRE_Basic) {
-  policy::affiliation_test_helper::PreLoginUser(account_id_);
+  RunPreTest();
 }
 
 IN_PROC_BROWSER_TEST_P(EnterprisePlatformKeysTest, Basic) {
@@ -463,34 +240,34 @@ IN_PROC_BROWSER_TEST_P(EnterprisePlatformKeysTest, Basic) {
   // Only if the system token exists, and the current user is of the same domain
   // as the device is enrolled to, the system token is available to the
   // extension.
-  if (GetParam().system_token_ == SYSTEM_TOKEN_EXISTS &&
-      GetParam().device_status_ == DEVICE_STATUS_ENROLLED &&
-      GetParam().user_affiliation_ == USER_AFFILIATION_ENROLLED_DOMAIN) {
+  if (system_token_status() == SystemTokenStatus::EXISTS &&
+      enrollment_status() == EnrollmentStatus::ENROLLED &&
+      user_status() == UserStatus::MANAGED_AFFILIATED_DOMAIN) {
     system_token_availability = "systemTokenEnabled";
   }
 
-  ASSERT_TRUE(TestExtension(CreateBrowser(profile()),
+  ASSERT_TRUE(TestExtension(
       base::StringPrintf("chrome-extension://%s/basic.html?%s",
-                         kTestExtensionID,
-                         system_token_availability.c_str())))
+                         kTestExtensionID, system_token_availability.c_str())))
       << message_;
 }
 
 INSTANTIATE_TEST_CASE_P(
     CheckSystemTokenAvailability,
     EnterprisePlatformKeysTest,
-    ::testing::Values(Params(SYSTEM_TOKEN_EXISTS,
-                             DEVICE_STATUS_ENROLLED,
-                             USER_AFFILIATION_ENROLLED_DOMAIN),
-                      Params(SYSTEM_TOKEN_EXISTS,
-                             DEVICE_STATUS_ENROLLED,
-                             USER_AFFILIATION_UNRELATED),
-                      Params(SYSTEM_TOKEN_EXISTS,
-                             DEVICE_STATUS_NOT_ENROLLED,
-                             USER_AFFILIATION_UNRELATED),
-                      Params(SYSTEM_TOKEN_NOT_EXISTS,
-                             DEVICE_STATUS_ENROLLED,
-                             USER_AFFILIATION_ENROLLED_DOMAIN)));
+    ::testing::Values(
+        Params(PlatformKeysTestBase::SystemTokenStatus::EXISTS,
+               PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_AFFILIATED_DOMAIN),
+        Params(PlatformKeysTestBase::SystemTokenStatus::EXISTS,
+               PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_OTHER_DOMAIN),
+        Params(PlatformKeysTestBase::SystemTokenStatus::EXISTS,
+               PlatformKeysTestBase::EnrollmentStatus::NOT_ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_OTHER_DOMAIN),
+        Params(PlatformKeysTestBase::SystemTokenStatus::DOES_NOT_EXIST,
+               PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_AFFILIATED_DOMAIN)));
 
 class EnterprisePlatformKeysTestNonPolicyInstalledExtension
     : public EnterprisePlatformKeysTest {};
diff --git a/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.cc b/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.cc
index 6584caaf05a..7a5f1b4b2c8 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.cc
@@ -278,9 +278,9 @@ void EPKPChallengeKeyBase::AskForUserConsentCallback(
 
 void EPKPChallengeKeyBase::GetCertificateCallback(
     const base::Callback<void(PrepareKeyResult)>& callback,
-    bool success,
+    chromeos::attestation::AttestationStatus status,
     const std::string& pem_certificate_chain) {
-  if (!success) {
+  if (status != chromeos::attestation::ATTESTATION_SUCCESS) {
     callback.Run(PREPARE_KEY_GET_CERTIFICATE_FAILED);
     return;
   }
diff --git a/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.h b/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.h
index 61ab6b36d32..a80e5d5930f 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.h
+++ b/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api.h
@@ -151,7 +151,7 @@ class EPKPChallengeKeyBase {
       bool result);
   void GetCertificateCallback(
       const base::Callback<void(PrepareKeyResult)>& callback,
-      bool success,
+      chromeos::attestation::AttestationStatus status,
       const std::string& pem_certificate_chain);
 
   chromeos::InstallAttributes* install_attributes_;
diff --git a/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api_unittest.cc b/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api_unittest.cc
index 748d1f8f198..f81fd5c960b 100644
--- a/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/enterprise_platform_keys_private/enterprise_platform_keys_private_api_unittest.cc
@@ -111,10 +111,12 @@ void GetCertificateCallbackTrue(
     const chromeos::attestation::AttestationFlow::CertificateCallback&
         callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(callback, true, "certificate"));
+      FROM_HERE,
+      base::BindRepeating(callback, chromeos::attestation::ATTESTATION_SUCCESS,
+                          "certificate"));
 }
 
-void GetCertificateCallbackFalse(
+void GetCertificateCallbackUnspecifiedFailure(
     chromeos::attestation::AttestationCertificateProfile certificate_profile,
     const AccountId& account_id,
     const std::string& request_origin,
@@ -122,7 +124,24 @@ void GetCertificateCallbackFalse(
     const chromeos::attestation::AttestationFlow::CertificateCallback&
         callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(callback, false, ""));
+      FROM_HERE,
+      base::BindRepeating(
+          callback, chromeos::attestation::ATTESTATION_UNSPECIFIED_FAILURE,
+          ""));
+}
+
+void GetCertificateCallbackBadRequestFailure(
+    chromeos::attestation::AttestationCertificateProfile certificate_profile,
+    const AccountId& account_id,
+    const std::string& request_origin,
+    bool force_new_key,
+    const chromeos::attestation::AttestationFlow::CertificateCallback&
+        callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindRepeating(
+          callback,
+          chromeos::attestation::ATTESTATION_SERVER_BAD_REQUEST_FAILURE, ""));
 }
 
 class EPKPChallengeKeyTestBase : public BrowserWithTestWindowTest {
@@ -279,7 +298,7 @@ TEST_F(EPKPChallengeMachineKeyTest, DoesKeyExistDbusFailed) {
 
 TEST_F(EPKPChallengeMachineKeyTest, GetCertificateFailed) {
   EXPECT_CALL(mock_attestation_flow_, GetCertificate(_, _, _, _, _))
-      .WillRepeatedly(Invoke(GetCertificateCallbackFalse));
+      .WillRepeatedly(Invoke(GetCertificateCallbackUnspecifiedFailure));
 
   EXPECT_EQ(GetCertificateError(kGetCertificateFailed),
             utils::RunFunctionAndReturnError(func_.get(), kArgs, browser()));
@@ -430,9 +449,17 @@ TEST_F(EPKPChallengeUserKeyTest, DoesKeyExistDbusFailed) {
             utils::RunFunctionAndReturnError(func_.get(), kArgs, browser()));
 }
 
-TEST_F(EPKPChallengeUserKeyTest, GetCertificateFailed) {
+TEST_F(EPKPChallengeUserKeyTest, GetCertificateFailedWithUnspecifiedFailure) {
+  EXPECT_CALL(mock_attestation_flow_, GetCertificate(_, _, _, _, _))
+      .WillRepeatedly(Invoke(GetCertificateCallbackUnspecifiedFailure));
+
+  EXPECT_EQ(GetCertificateError(kGetCertificateFailed),
+            utils::RunFunctionAndReturnError(func_.get(), kArgs, browser()));
+}
+
+TEST_F(EPKPChallengeUserKeyTest, GetCertificateFailedWithBadRequestFailure) {
   EXPECT_CALL(mock_attestation_flow_, GetCertificate(_, _, _, _, _))
-      .WillRepeatedly(Invoke(GetCertificateCallbackFalse));
+      .WillRepeatedly(Invoke(GetCertificateCallbackBadRequestFailure));
 
   EXPECT_EQ(GetCertificateError(kGetCertificateFailed),
             utils::RunFunctionAndReturnError(func_.get(), kArgs, browser()));
diff --git a/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc b/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc
index 9d3ecde9746..c057b5bebfb 100644
--- a/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc
@@ -27,7 +27,6 @@
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
@@ -799,10 +798,10 @@ IN_PROC_BROWSER_TEST_F(BrowserActionApiTest, BrowserActionWithRectangularIcon) {
 // Regression test for crbug.com/584747.
 IN_PROC_BROWSER_TEST_F(BrowserActionApiTest, BrowserActionOpenPopupOnPopup) {
   // Open a new web popup window.
-  chrome::NavigateParams params(browser(), GURL("http://www.google.com/"),
-                                ui::PAGE_TRANSITION_LINK);
+  NavigateParams params(browser(), GURL("http://www.google.com/"),
+                        ui::PAGE_TRANSITION_LINK);
   params.disposition = WindowOpenDisposition::NEW_POPUP;
-  params.window_action = chrome::NavigateParams::SHOW_WINDOW;
+  params.window_action = NavigateParams::SHOW_WINDOW;
   ui_test_utils::NavigateToURL(&params);
   Browser* popup_browser = params.browser;
   // Verify it is a popup, and it is the active window.
diff --git a/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc b/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc
index 3155fdf0b90..d2a853e242d 100644
--- a/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc
+++ b/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "build/build_config.h"
@@ -95,7 +97,7 @@ class BrowserActionInteractiveTest : public ExtensionApiTest {
 
   // BrowserTestBase:
   void SetUpOnMainThread() override {
-    host_watcher_ = base::MakeUnique<ExtensionHostWatcher>();
+    host_watcher_ = std::make_unique<ExtensionHostWatcher>();
     ExtensionApiTest::SetUpOnMainThread();
     EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
   }
@@ -132,14 +134,16 @@ class BrowserActionInteractiveTest : public ExtensionApiTest {
   }
 
   // Open an extension popup via the chrome.browserAction.openPopup API.
-  void OpenPopupViaAPI() {
+  void OpenPopupViaAPI(bool will_reply) {
     // Setup the notification observer to wait for the popup to finish loading.
     content::WindowedNotificationObserver frame_observer(
         content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
         content::NotificationService::AllSources());
+    ExtensionTestMessageListener listener("ready", will_reply);
     // Show first popup in first window and expect it to have loaded.
     ASSERT_TRUE(RunExtensionSubtest("browser_action/open_popup",
                                     "open_popup_succeeds.html")) << message_;
+    EXPECT_TRUE(listener.WaitUntilSatisfied());
     frame_observer.Wait();
     EnsurePopupActive();
   }
@@ -203,7 +207,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest, TestOpenPopup) {
   // Setup extension message listener to wait for javascript to finish running.
   ExtensionTestMessageListener listener("ready", true);
   {
-    OpenPopupViaAPI();
+    OpenPopupViaAPI(true);
     EXPECT_TRUE(browserActionBar.HasPopup());
     browserActionBar.HidePopup();
   }
@@ -329,7 +333,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
   if (!ShouldRunPopupTest())
     return;
 
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser()->profile())->extension_service();
   ASSERT_FALSE(
@@ -346,7 +350,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
 IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest, FocusLossClosesPopup1) {
   if (!ShouldRunPopupTest())
     return;
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   ClosePopupViaFocusLoss();
 }
 
@@ -374,7 +378,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest, TabSwitchClosesPopup) {
   ASSERT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(browser()->tab_strip_model()->GetWebContentsAt(1),
             browser()->tab_strip_model()->GetActiveWebContents());
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
 
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
@@ -392,7 +396,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
     return;
 
   // First, we open a popup.
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   BrowserActionTestUtil browser_action_test_util(browser());
   EXPECT_TRUE(browser_action_test_util.HasPopup());
 
@@ -449,7 +453,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
   if (!ShouldRunPopupTest())
     return;
 
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   BrowserActionTestUtil test_util(browser());
   const gfx::NativeView view = test_util.GetPopupNativeView();
   EXPECT_NE(static_cast<gfx::NativeView>(NULL), view);
diff --git a/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc b/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc
index bf0c9186dd4..017614b8028 100644
--- a/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc
+++ b/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc
@@ -5,12 +5,12 @@
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 
 #include <stddef.h>
+#include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -165,7 +165,7 @@ void ExtensionActionAPI::SetBrowserActionVisibility(
 
   GetExtensionPrefs()->UpdateExtensionPref(
       extension_id, kBrowserActionVisible,
-      base::MakeUnique<base::Value>(visible));
+      std::make_unique<base::Value>(visible));
   for (auto& observer : observers_)
     observer.OnExtensionActionVisibilityChanged(extension_id, visible);
 }
@@ -274,7 +274,7 @@ void ExtensionActionAPI::DispatchEventToExtension(
   if (!EventRouter::Get(context))
     return;
 
-  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+  auto event = std::make_unique<Event>(histogram_value, event_name,
                                        std::move(event_args), context);
   event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
   EventRouter::Get(context)
@@ -516,19 +516,19 @@ ExtensionActionSetBadgeBackgroundColorFunction::RunExtensionAction() {
 ExtensionFunction::ResponseAction
 ExtensionActionGetTitleFunction::RunExtensionAction() {
   return RespondNow(OneArgument(
-      base::MakeUnique<base::Value>(extension_action_->GetTitle(tab_id_))));
+      std::make_unique<base::Value>(extension_action_->GetTitle(tab_id_))));
 }
 
 ExtensionFunction::ResponseAction
 ExtensionActionGetPopupFunction::RunExtensionAction() {
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(
+  return RespondNow(OneArgument(std::make_unique<base::Value>(
       extension_action_->GetPopupUrl(tab_id_).spec())));
 }
 
 ExtensionFunction::ResponseAction
 ExtensionActionGetBadgeTextFunction::RunExtensionAction() {
   return RespondNow(OneArgument(
-      base::MakeUnique<base::Value>(extension_action_->GetBadgeText(tab_id_))));
+      std::make_unique<base::Value>(extension_action_->GetBadgeText(tab_id_))));
 }
 
 ExtensionFunction::ResponseAction
diff --git a/chromium/chrome/browser/extensions/api/extension_action/extension_action_apitest.cc b/chromium/chrome/browser/extensions/api/extension_action/extension_action_apitest.cc
new file mode 100644
index 00000000000..abc8ca885cc
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/extension_action/extension_action_apitest.cc
@@ -0,0 +1,163 @@
+// 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 <map>
+#include <string>
+
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "base/scoped_observer.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/browser/extensions/browsertest_util.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/test_extension_dir.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "extensions/browser/state_store.h"
+#include "extensions/test/extension_test_message_listener.h"
+
+namespace extensions {
+namespace {
+
+// A helper class to track StateStore changes.
+class TestStateStoreObserver : public StateStore::TestObserver {
+ public:
+  TestStateStoreObserver(content::BrowserContext* context,
+                         const std::string& extension_id)
+      : extension_id_(extension_id), scoped_observer_(this) {
+    scoped_observer_.Add(ExtensionSystem::Get(context)->state_store());
+  }
+  ~TestStateStoreObserver() override {}
+
+  void WillSetExtensionValue(const std::string& extension_id,
+                             const std::string& key) override {
+    if (extension_id == extension_id_)
+      ++updated_values_[key];
+  }
+
+  int CountForKey(const std::string& key) const {
+    auto iter = updated_values_.find(key);
+    return iter == updated_values_.end() ? 0 : iter->second;
+  }
+
+ private:
+  std::string extension_id_;
+  std::map<std::string, int> updated_values_;
+
+  ScopedObserver<StateStore, StateStore::TestObserver> scoped_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestStateStoreObserver);
+};
+
+// A helper class to observe ExtensionActionAPI changes.
+class TestExtensionActionAPIObserver : public ExtensionActionAPI::Observer {
+ public:
+  TestExtensionActionAPIObserver(content::BrowserContext* context,
+                                 const std::string& extension_id)
+      : extension_id_(extension_id), scoped_observer_(this) {
+    scoped_observer_.Add(ExtensionActionAPI::Get(context));
+  }
+  ~TestExtensionActionAPIObserver() override {}
+
+  void OnExtensionActionUpdated(
+      ExtensionAction* extension_action,
+      content::WebContents* web_contents,
+      content::BrowserContext* browser_context) override {
+    if (extension_action->extension_id() == extension_id_) {
+      last_web_contents_ = web_contents;
+      run_loop_.QuitWhenIdle();
+    }
+  }
+
+  const content::WebContents* last_web_contents() const {
+    return last_web_contents_;
+  }
+
+  void Wait() { run_loop_.Run(); }
+
+ private:
+  content::WebContents* last_web_contents_ = nullptr;
+  std::string extension_id_;
+  base::RunLoop run_loop_;
+  ScopedObserver<ExtensionActionAPI, ExtensionActionAPI::Observer>
+      scoped_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestExtensionActionAPIObserver);
+};
+
+}  // namespace
+
+using ExtensionActionAPITest = ExtensionApiTest;
+
+// Check that updating the browser action badge for a specific tab id does not
+// cause a disk write (since we only persist the defaults).
+IN_PROC_BROWSER_TEST_F(ExtensionActionAPITest, TestNoUnnecessaryIO) {
+  ExtensionTestMessageListener ready_listener("ready", false);
+
+  TestExtensionDir test_dir;
+  test_dir.WriteManifest(
+      R"({
+           "name": "Extension",
+           "description": "An extension",
+           "manifest_version": 2,
+           "version": "0.1",
+           "browser_action": {},
+           "background": { "scripts": ["background.js"] }
+         })");
+  test_dir.WriteFile(FILE_PATH_LITERAL("background.js"),
+                     "chrome.test.sendMessage('ready');");
+
+  const Extension* extension = LoadExtension(test_dir.UnpackedPath());
+  ASSERT_TRUE(extension);
+  ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
+
+  // The script template to update the browser action.
+  constexpr char kUpdate[] =
+      R"(chrome.browserAction.setBadgeText(%s);
+         domAutomationController.send('pass');)";
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  int tab_id = SessionTabHelper::IdForTab(web_contents);
+  constexpr char kBrowserActionKey[] = "browser_action";
+  TestStateStoreObserver test_state_store_observer(profile(), extension->id());
+
+  {
+    TestExtensionActionAPIObserver test_api_observer(profile(),
+                                                     extension->id());
+    // First, update a specific tab.
+    std::string update_options =
+        base::StringPrintf("{text: 'New Text', tabId: %d}", tab_id);
+    EXPECT_EQ("pass", browsertest_util::ExecuteScriptInBackgroundPage(
+                          profile(), extension->id(),
+                          base::StringPrintf(kUpdate, update_options.c_str())));
+    test_api_observer.Wait();
+
+    // The action update should be associated with the specific tab.
+    EXPECT_EQ(web_contents, test_api_observer.last_web_contents());
+    // Since this was only updating a specific tab, this should *not* result in
+    // a StateStore write. We should only write to the StateStore with new
+    // default values.
+    EXPECT_EQ(0, test_state_store_observer.CountForKey(kBrowserActionKey));
+  }
+
+  {
+    TestExtensionActionAPIObserver test_api_observer(profile(),
+                                                     extension->id());
+    // Next, update the default badge text.
+    EXPECT_EQ("pass",
+              browsertest_util::ExecuteScriptInBackgroundPage(
+                  profile(), extension->id(),
+                  base::StringPrintf(kUpdate, "{text: 'Default Text'}")));
+    test_api_observer.Wait();
+    // The action update should not be associated with a specific tab.
+    EXPECT_EQ(nullptr, test_api_observer.last_web_contents());
+
+    // This *should* result in a StateStore write, since we persist the default
+    // state of the extension action.
+    EXPECT_EQ(1, test_state_store_observer.CountForKey(kBrowserActionKey));
+  }
+}
+
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/feedback_private/feedback_browsertest.cc b/chromium/chrome/browser/extensions/api/feedback_private/feedback_browsertest.cc
index eb9cb6eb2d0..05be2e18013 100644
--- a/chromium/chrome/browser/extensions/api/feedback_private/feedback_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/feedback_private/feedback_browsertest.cc
@@ -79,9 +79,9 @@ class FeedbackTest : public ExtensionBrowserTest {
     extensions::FeedbackPrivateAPI* api =
         extensions::FeedbackPrivateAPI::GetFactoryInstance()->Get(
             browser()->profile());
-    api->RequestFeedbackForFlow("Test description", "Test tag",
-                                extra_diagnostics, GURL("http://www.test.com"),
-                                flow);
+    api->RequestFeedbackForFlow("Test description", "Test placeholder",
+                                "Test tag", extra_diagnostics,
+                                GURL("http://www.test.com"), flow);
   }
 };
 
@@ -100,7 +100,14 @@ IN_PROC_BROWSER_TEST_F(FeedbackTest, MAYBE_ShowFeedback) {
   VerifyFeedbackAppLaunch();
 }
 
-IN_PROC_BROWSER_TEST_F(FeedbackTest, ShowLoginFeedback) {
+// Disabled for ASan due to flakiness on Mac ASan 64 Tests (1).
+// See crbug.com/757243.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_ShowLoginFeedback DISABLED_ShowLoginFeedback
+#else
+#define MAYBE_ShowLoginFeedback ShowLoginFeedback
+#endif
+IN_PROC_BROWSER_TEST_F(FeedbackTest, MAYBE_ShowLoginFeedback) {
   WaitForExtensionViewsToLoad();
 
   ASSERT_TRUE(IsFeedbackAppAvailable());
@@ -122,9 +129,16 @@ IN_PROC_BROWSER_TEST_F(FeedbackTest, ShowLoginFeedback) {
   EXPECT_TRUE(bool_result);
 }
 
+// Disabled for ASan due to flakiness on Mac ASan 64 Tests (1).
+// See crbug.com/757243.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_AnonymousUser DISABLED_AnonymousUser
+#else
+#define MAYBE_AnonymousUser AnonymousUser
+#endif
 // Tests that there's an option in the email drop down box with a value
 // 'anonymous_user'.
-IN_PROC_BROWSER_TEST_F(FeedbackTest, AnonymousUser) {
+IN_PROC_BROWSER_TEST_F(FeedbackTest, MAYBE_AnonymousUser) {
   WaitForExtensionViewsToLoad();
 
   ASSERT_TRUE(IsFeedbackAppAvailable());
@@ -153,9 +167,16 @@ IN_PROC_BROWSER_TEST_F(FeedbackTest, AnonymousUser) {
   EXPECT_TRUE(bool_result);
 }
 
+// Disabled for ASan due to flakiness on Mac ASan 64 Tests (1).
+// See crbug.com/757243.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_ExtraDiagnostics DISABLED_ExtraDiagnostics
+#else
+#define MAYBE_ExtraDiagnostics ExtraDiagnostics
+#endif
 // Ensures that when extra diagnostics are provided with feedback, they are
 // injected properly in the system information.
-IN_PROC_BROWSER_TEST_F(FeedbackTest, ExtraDiagnostics) {
+IN_PROC_BROWSER_TEST_F(FeedbackTest, MAYBE_ExtraDiagnostics) {
   WaitForExtensionViewsToLoad();
 
   ASSERT_TRUE(IsFeedbackAppAvailable());
diff --git a/chromium/chrome/browser/extensions/api/file_system/OWNERS b/chromium/chrome/browser/extensions/api/file_system/OWNERS
index ac81da73b61..64f66776b4a 100644
--- a/chromium/chrome/browser/extensions/api/file_system/OWNERS
+++ b/chromium/chrome/browser/extensions/api/file_system/OWNERS
@@ -1,3 +1,2 @@
 benwells@chromium.org
-mtomasz@chromium.org
 sammc@chromium.org
diff --git a/chromium/chrome/browser/extensions/api/file_system/chrome_file_system_delegate.cc b/chromium/chrome/browser/extensions/api/file_system/chrome_file_system_delegate.cc
index 2bad956bd95..57c2cf505ee 100644
--- a/chromium/chrome/browser/extensions/api/file_system/chrome_file_system_delegate.cc
+++ b/chromium/chrome/browser/extensions/api/file_system/chrome_file_system_delegate.cc
@@ -12,7 +12,6 @@
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/extensions/api/file_system/file_entry_picker.h"
@@ -215,7 +214,7 @@ void DispatchVolumeListChangeEvent(content::BrowserContext* browser_context) {
       continue;
     event_router->DispatchEventToExtension(
         extension->id(),
-        base::MakeUnique<Event>(
+        std::make_unique<Event>(
             events::FILE_SYSTEM_ON_VOLUME_LIST_CHANGED,
             file_system::OnVolumeListChanged::kEventName,
             file_system::OnVolumeListChanged::Create(event_args)));
diff --git a/chromium/chrome/browser/extensions/api/file_system/consent_provider.cc b/chromium/chrome/browser/extensions/api/file_system/consent_provider.cc
index a0bd54b184f..b2fc4b258d3 100644
--- a/chromium/chrome/browser/extensions/api/file_system/consent_provider.cc
+++ b/chromium/chrome/browser/extensions/api/file_system/consent_provider.cc
@@ -198,8 +198,8 @@ void ConsentProviderDelegate::ShowNotification(
     const Extension& extension,
     const base::WeakPtr<file_manager::Volume>& volume,
     bool writable) {
-  RequestFileSystemNotification::ShowAutoGrantedNotification(
-      profile_, extension, volume, writable);
+  ShowNotificationForAutoGrantedRequestFileSystem(profile_, extension, volume,
+                                                  writable);
 }
 
 bool ConsentProviderDelegate::IsAutoLaunched(const Extension& extension) {
diff --git a/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.cc b/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.cc
index 527128ce55a..af719794f36 100644
--- a/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.cc
+++ b/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.cc
@@ -6,16 +6,19 @@
 
 #include <utility>
 
+#include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 #include "chrome/browser/extensions/chrome_app_icon_loader.h"
+#include "chrome/browser/notifications/notification_display_service.h"
+#include "chrome/browser/ui/app_icon_loader.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/extension.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_delegate.h"
 #include "ui/message_center/notification_types.h"
@@ -24,21 +27,66 @@
 using file_manager::Volume;
 using message_center::Notification;
 
+namespace extensions {
+
 namespace {
 
 // Extension icon size for the notification.
 const int kIconSize = 48;
 
-std::unique_ptr<message_center::Notification> CreateAutoGrantedNotification(
-    const extensions::Extension& extension,
+// Loads an app's icon and uses it to display a notification.
+class AppNotificationLauncher : public AppIconLoaderDelegate {
+ public:
+  // This class owns and deletes itself after showing the notification.
+  AppNotificationLauncher() = default;
+
+  void InitAndShow(Profile* profile,
+                   const Extension& extension,
+                   std::unique_ptr<message_center::Notification> notification) {
+    profile_ = profile;
+    pending_notification_ = std::move(notification);
+
+    icon_loader_ =
+        std::make_unique<ChromeAppIconLoader>(profile, kIconSize, this);
+    icon_loader_->FetchImage(extension.id());
+
+    // |this| may be destroyed!
+  }
+
+  // AppIconLoaderDelegate overrides:
+  void OnAppImageUpdated(const std::string& id,
+                         const gfx::ImageSkia& image) override {
+    extension_icon_.reset(new gfx::Image(image));
+
+    pending_notification_->set_icon(*extension_icon_);
+    NotificationDisplayService::GetForProfile(profile_)->Display(
+        NotificationHandler::Type::TRANSIENT, *pending_notification_);
+    delete this;
+  }
+
+ private:
+  ~AppNotificationLauncher() override = default;
+
+  Profile* profile_;
+  std::unique_ptr<AppIconLoader> icon_loader_;
+  std::unique_ptr<gfx::Image> extension_icon_;
+  std::unique_ptr<message_center::Notification> pending_notification_;
+
+  DISALLOW_COPY_AND_ASSIGN(AppNotificationLauncher);
+};
+
+}  // namespace
+
+void ShowNotificationForAutoGrantedRequestFileSystem(
+    Profile* profile,
+    const Extension& extension,
     const base::WeakPtr<Volume>& volume,
-    bool writable,
-    message_center::NotificationDelegate* delegate) {
-  DCHECK(delegate);
+    bool writable) {
+  DCHECK(profile);
 
   // If the volume is gone, then do not show the notification.
   if (!volume.get())
-    return std::unique_ptr<message_center::Notification>(nullptr);
+    return;
 
   const std::string notification_id =
       extension.id() + "-" + volume->volume_id();
@@ -62,63 +110,11 @@ std::unique_ptr<message_center::Notification> CreateAutoGrantedNotification(
       GURL(),
       message_center::NotifierId(message_center::NotifierId::SYSTEM_COMPONENT,
                                  notification_id),
-      data, delegate));
-
-  return notification;
-}
-
-}  // namespace
+      data, base::MakeRefCounted<message_center::NotificationDelegate>()));
 
-// static
-void RequestFileSystemNotification::ShowAutoGrantedNotification(
-    Profile* profile,
-    const extensions::Extension& extension,
-    const base::WeakPtr<Volume>& volume,
-    bool writable) {
-  DCHECK(profile);
-  scoped_refptr<RequestFileSystemNotification>
-      request_file_system_notification = base::WrapRefCounted(
-          new RequestFileSystemNotification(profile, extension));
-  std::unique_ptr<message_center::Notification> notification(
-      CreateAutoGrantedNotification(
-          extension, volume, writable,
-          request_file_system_notification.get() /* delegate */));
-  if (notification.get())
-    request_file_system_notification->Show(std::move(notification));
+  // AppNotificationLauncher will delete itself.
+  (new AppNotificationLauncher())
+      ->InitAndShow(profile, extension, std::move(notification));
 }
 
-void RequestFileSystemNotification::OnAppImageUpdated(
-    const std::string& id, const gfx::ImageSkia& image) {
-  extension_icon_.reset(new gfx::Image(image));
-
-  // If there is a pending notification, then show it now.
-  if (pending_notification_.get()) {
-    pending_notification_->set_icon(*extension_icon_.get());
-    g_browser_process->message_center()->AddNotification(
-        std::move(pending_notification_));
-  }
-}
-
-RequestFileSystemNotification::RequestFileSystemNotification(
-    Profile* profile,
-    const extensions::Extension& extension)
-    : icon_loader_(
-          new extensions::ChromeAppIconLoader(profile, kIconSize, this)) {
-  icon_loader_->FetchImage(extension.id());
-}
-
-RequestFileSystemNotification::~RequestFileSystemNotification() {
-}
-
-void RequestFileSystemNotification::Show(
-    std::unique_ptr<message_center::Notification> notification) {
-  pending_notification_ = std::move(notification);
-  // If the extension icon is not known yet, then defer showing the notification
-  // until it is (from SetAppImage).
-  if (!extension_icon_)
-    return;
-
-  pending_notification_->set_icon(*extension_icon_.get());
-  g_browser_process->message_center()->AddNotification(
-      std::move(pending_notification_));
-}
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.h b/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.h
index 25285313d43..45ba12d06f9 100644
--- a/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.h
+++ b/chromium/chrome/browser/extensions/api/file_system/request_file_system_notification.h
@@ -8,60 +8,25 @@
 #include <memory>
 #include <string>
 
-#include "base/callback.h"
-#include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "chrome/browser/ui/app_icon_loader.h"
-#include "ui/message_center/notification_delegate.h"
 
 class Profile;
 
-namespace extensions {
-class Extension;
-}  // namespace extensions
-
 namespace file_manager {
 class Volume;
 }  // namespace file_manager
 
-namespace gfx {
-class Image;
-class ImageSkia;
-}  // namespace gfx
-
-namespace message_center {
-class Notification;
-}  // namespace message_center
-
-// Shows notifications for the chrome.fileSystem.requestFileSystem() API.
-class RequestFileSystemNotification
-    : public message_center::NotificationDelegate,
-      public AppIconLoaderDelegate {
- public:
-  // Shows a notification about automatically granted access to a file system.
-  static void ShowAutoGrantedNotification(
-      Profile* profile,
-      const extensions::Extension& extension,
-      const base::WeakPtr<file_manager::Volume>& volume,
-      bool writable);
-
- private:
-  RequestFileSystemNotification(Profile* profile,
-                                const extensions::Extension& extension);
-  ~RequestFileSystemNotification() override;
-
-  // Shows the notification. Can be called only once.
-  void Show(std::unique_ptr<message_center::Notification> notification);
-
-  // AppIconLoaderDelegate overrides:
-  void OnAppImageUpdated(const std::string& id,
-                         const gfx::ImageSkia& image) override;
+namespace extensions {
+class Extension;
 
-  std::unique_ptr<AppIconLoader> icon_loader_;
-  std::unique_ptr<gfx::Image> extension_icon_;
-  std::unique_ptr<message_center::Notification> pending_notification_;
+// Shows a notification about automatically granted access to a file system,
+// i.e. the chrome.fileSystem.requestFileSystem() API.
+void ShowNotificationForAutoGrantedRequestFileSystem(
+    Profile* profile,
+    const extensions::Extension& extension,
+    const base::WeakPtr<file_manager::Volume>& volume,
+    bool writable);
 
-  DISALLOW_COPY_AND_ASSIGN(RequestFileSystemNotification);
-};
+}  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_FILE_SYSTEM_REQUEST_FILE_SYSTEM_NOTIFICATION_H_
diff --git a/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.cc b/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.cc
index eb57d222215..e43333db7e9 100644
--- a/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.cc
+++ b/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.cc
@@ -15,7 +15,6 @@
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -304,9 +303,9 @@ bool FontSettingsGetFontListFunction::CopyFontsToResult(
 
     std::unique_ptr<base::DictionaryValue> font_name(
         new base::DictionaryValue());
-    font_name->Set(kFontIdKey, base::MakeUnique<base::Value>(name));
+    font_name->Set(kFontIdKey, std::make_unique<base::Value>(name));
     font_name->Set(kDisplayNameKey,
-                   base::MakeUnique<base::Value>(localized_name));
+                   std::make_unique<base::Value>(localized_name));
     result->Append(std::move(font_name));
   }
 
diff --git a/chromium/chrome/browser/extensions/api/gcm/gcm_api.cc b/chromium/chrome/browser/extensions/api/gcm/gcm_api.cc
index 7f878c3b4fd..b486d37017b 100644
--- a/chromium/chrome/browser/extensions/api/gcm/gcm_api.cc
+++ b/chromium/chrome/browser/extensions/api/gcm/gcm_api.cc
@@ -7,11 +7,11 @@
 #include <stddef.h>
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -128,7 +128,7 @@ bool GcmRegisterFunction::DoWork() {
 void GcmRegisterFunction::CompleteFunctionWithResult(
     const std::string& registration_id,
     gcm::GCMClient::Result result) {
-  SetResult(base::MakeUnique<base::Value>(registration_id));
+  SetResult(std::make_unique<base::Value>(registration_id));
   SetError(GcmResultToError(result));
   SendResponse(gcm::GCMClient::SUCCESS == result);
 }
@@ -182,7 +182,7 @@ bool GcmSendFunction::DoWork() {
 void GcmSendFunction::CompleteFunctionWithResult(
     const std::string& message_id,
     gcm::GCMClient::Result result) {
-  SetResult(base::MakeUnique<base::Value>(message_id));
+  SetResult(std::make_unique<base::Value>(message_id));
   SetError(GcmResultToError(result));
   SendResponse(gcm::GCMClient::SUCCESS == result);
 }
diff --git a/chromium/chrome/browser/extensions/api/history/history_api.cc b/chromium/chrome/browser/extensions/api/history/history_api.cc
index fe4f312e062..7024cdc1267 100644
--- a/chromium/chrome/browser/extensions/api/history/history_api.cc
+++ b/chromium/chrome/browser/extensions/api/history/history_api.cc
@@ -173,7 +173,7 @@ void HistoryEventRouter::DispatchEvent(
     const std::string& event_name,
     std::unique_ptr<base::ListValue> event_args) {
   if (profile && EventRouter::Get(profile)) {
-    auto event = base::MakeUnique<Event>(histogram_value, event_name,
+    auto event = std::make_unique<Event>(histogram_value, event_name,
                                          std::move(event_args), profile);
     EventRouter::Get(profile)->BroadcastEvent(std::move(event));
   }
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc b/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc
index 7582880e793..7c80a0cf2c0 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ -143,7 +144,7 @@ class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
   // Provide wrappers of AsynchronousFunctionRunner for convenience.
   void RunFunctionAsync(UIThreadExtensionFunction* function,
                         const std::string& args) {
-    async_function_runner_ = base::MakeUnique<AsyncFunctionRunner>();
+    async_function_runner_ = std::make_unique<AsyncFunctionRunner>();
     async_function_runner_->RunFunctionAsync(function, args,
                                              browser()->profile());
   }
@@ -299,7 +300,7 @@ class FakeGetAuthTokenFunction : public IdentityGetAuthTokenFunction {
 
   void set_mint_token_result(TestOAuth2MintTokenFlow::ResultType result_type) {
     set_mint_token_flow(
-        base::MakeUnique<TestOAuth2MintTokenFlow>(result_type, this));
+        std::make_unique<TestOAuth2MintTokenFlow>(result_type, this));
   }
 
   void set_scope_ui_failure(GaiaWebAuthFlow::Failure failure) {
@@ -820,13 +821,6 @@ class GetAuthTokenFunctionTest
       return;
     base::ResetAndReturn(&on_access_token_requested_).Run();
   }
-  void OnFetchAccessTokenComplete(const std::string& account_id,
-                                  const std::string& consumer_id,
-                                  const OAuth2TokenService::ScopeSet& scopes,
-                                  GoogleServiceAuthError error,
-                                  base::Time expiration_time) override {}
-  void OnTokenRemoved(const std::string& account_id,
-                      const OAuth2TokenService::ScopeSet& scopes) override {}
 
   std::string extension_id_;
   std::set<std::string> oauth_scopes_;
@@ -1443,7 +1437,7 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, NoninteractiveShutdown) {
   scoped_refptr<FakeGetAuthTokenFunction> func(new FakeGetAuthTokenFunction());
   func->set_extension(extension.get());
 
-  func->set_mint_token_flow(base::MakeUnique<TestHangOAuth2MintTokenFlow>());
+  func->set_mint_token_flow(std::make_unique<TestHangOAuth2MintTokenFlow>());
   RunFunctionAsync(func.get(), "[{\"interactive\": false}]");
 
   // After the request is canceled, the function will complete.
@@ -1959,8 +1953,8 @@ class GetAuthTokenFunctionPublicSessionTest : public GetAuthTokenFunctionTest {
 
     // Set up fake install attributes to make the device appeared as
     // enterprise-managed.
-     std::unique_ptr<chromeos::StubInstallAttributes> attributes
-         = base::MakeUnique<chromeos::StubInstallAttributes>();
+     std::unique_ptr<chromeos::StubInstallAttributes> attributes =
+         std::make_unique<chromeos::StubInstallAttributes>();
      attributes->SetCloudManaged("example.com", "fake-id");
      policy::BrowserPolicyConnectorChromeOS::SetInstallAttributesForTesting(
          attributes.release());
@@ -2244,7 +2238,7 @@ class OnSignInChangedEventTest : public IdentityTestWithSignin {
   // chrome.identity.onSignInEventChanged() API.
   void AddExpectedEvent(std::unique_ptr<base::ListValue> args) {
     expected_events_.insert(
-        base::MakeUnique<Event>(events::IDENTITY_ON_SIGN_IN_CHANGED,
+        std::make_unique<Event>(events::IDENTITY_ON_SIGN_IN_CHANGED,
                                 api::identity::OnSignInChanged::kEventName,
                                 std::move(args), browser()->profile()));
   }
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.cc b/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.cc
index 022609e1721..6281011f2f0 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.cc
@@ -6,9 +6,9 @@
 
 #include "chrome/browser/extensions/api/identity/identity_api.h"
 #include "chrome/browser/extensions/api/identity/identity_constants.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/identity.h"
 #include "components/signin/core/browser/profile_management_switches.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/common/service_manager_connection.h"
 #include "services/identity/public/interfaces/account.mojom.h"
 #include "services/identity/public/interfaces/constants.mojom.h"
@@ -23,11 +23,11 @@ IdentityGetAccountsFunction::~IdentityGetAccountsFunction() {
 }
 
 ExtensionFunction::ResponseAction IdentityGetAccountsFunction::Run() {
-  if (GetProfile()->IsOffTheRecord()) {
+  if (browser_context()->IsOffTheRecord()) {
     return RespondNow(Error(identity_constants::kOffTheRecord));
   }
 
-  content::BrowserContext::GetConnectorFor(GetProfile())
+  content::BrowserContext::GetConnectorFor(browser_context())
       ->BindInterface(identity::mojom::kServiceName,
                       mojo::MakeRequest(&identity_manager_));
 
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.h b/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.h
index 76c33885f8d..1e3973c8d5d 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.h
+++ b/chromium/chrome/browser/extensions/api/identity/identity_get_accounts_function.h
@@ -5,13 +5,13 @@
 #ifndef CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_GET_ACCOUNTS_FUNCTION_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_GET_ACCOUNTS_FUNCTION_H_
 
-#include "chrome/browser/extensions/chrome_extension_function.h"
+#include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_function_histogram_value.h"
 #include "services/identity/public/interfaces/identity_manager.mojom.h"
 
 namespace extensions {
 
-class IdentityGetAccountsFunction : public ChromeUIThreadExtensionFunction {
+class IdentityGetAccountsFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("identity.getAccounts",
                              IDENTITY_GETACCOUNTS);
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.cc b/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.cc
index 27991bd3e63..3d31a6e98d9 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.cc
@@ -235,7 +235,7 @@ void IdentityGetAuthTokenFunction::CompleteAsyncRun(bool success) {
 
 void IdentityGetAuthTokenFunction::CompleteFunctionWithResult(
     const std::string& access_token) {
-  SetResult(base::MakeUnique<base::Value>(access_token));
+  SetResult(std::make_unique<base::Value>(access_token));
   CompleteAsyncRun(true);
 }
 
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.cc b/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.cc
index 7cc9db21ee2..085f4c7b41c 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.cc
@@ -5,8 +5,8 @@
 #include "chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.h"
 
 #include "chrome/browser/extensions/api/identity/identity_constants.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/identity.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/common/service_manager_connection.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ -22,7 +22,7 @@ IdentityGetProfileUserInfoFunction::~IdentityGetProfileUserInfoFunction() {
 }
 
 ExtensionFunction::ResponseAction IdentityGetProfileUserInfoFunction::Run() {
-  if (GetProfile()->IsOffTheRecord()) {
+  if (browser_context()->IsOffTheRecord()) {
     return RespondNow(Error(identity_constants::kOffTheRecord));
   }
 
@@ -32,7 +32,7 @@ ExtensionFunction::ResponseAction IdentityGetProfileUserInfoFunction::Run() {
     return RespondNow(OneArgument(profile_user_info.ToValue()));
   }
 
-  content::BrowserContext::GetConnectorFor(GetProfile())
+  content::BrowserContext::GetConnectorFor(browser_context())
       ->BindInterface(identity::mojom::kServiceName,
                       mojo::MakeRequest(&identity_manager_));
 
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.h b/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.h
index ad9536a7581..17a201c0649 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.h
+++ b/chromium/chrome/browser/extensions/api/identity/identity_get_profile_user_info_function.h
@@ -5,16 +5,15 @@
 #ifndef CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_GET_PROFILE_USER_INFO_FUNCTION_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_GET_PROFILE_USER_INFO_FUNCTION_H_
 
-#include "chrome/browser/extensions/chrome_extension_function.h"
 #include "components/signin/core/browser/account_info.h"
+#include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_function_histogram_value.h"
 #include "services/identity/public/cpp/account_state.h"
 #include "services/identity/public/interfaces/identity_manager.mojom.h"
 
 namespace extensions {
 
-class IdentityGetProfileUserInfoFunction
-    : public ChromeUIThreadExtensionFunction {
+class IdentityGetProfileUserInfoFunction : public UIThreadExtensionFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("identity.getProfileUserInfo",
                              IDENTITY_GETPROFILEUSERINFO);
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_launch_web_auth_flow_function.cc b/chromium/chrome/browser/extensions/api/identity/identity_launch_web_auth_flow_function.cc
index 882c858b85a..0be6cad7060 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_launch_web_auth_flow_function.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_launch_web_auth_flow_function.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/extensions/api/identity/identity_launch_web_auth_flow_function.h"
 
+#include <memory>
+
 #include "chrome/browser/extensions/api/identity/identity_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/identity.h"
@@ -91,7 +93,7 @@ void IdentityLaunchWebAuthFlowFunction::OnAuthFlowFailure(
 void IdentityLaunchWebAuthFlowFunction::OnAuthFlowURLChange(
     const GURL& redirect_url) {
   if (redirect_url.GetWithEmptyPath() == final_url_prefix_) {
-    SetResult(base::MakeUnique<base::Value>(redirect_url.spec()));
+    SetResult(std::make_unique<base::Value>(redirect_url.spec()));
     SendResponse(true);
     if (auth_flow_)
       auth_flow_.release()->DetachDelegateAndDelete();
diff --git a/chromium/chrome/browser/extensions/api/identity/web_auth_flow.cc b/chromium/chrome/browser/extensions/api/identity/web_auth_flow.cc
index aa4281a4467..d26238cd2d6 100644
--- a/chromium/chrome/browser/extensions/api/identity/web_auth_flow.cc
+++ b/chromium/chrome/browser/extensions/api/identity/web_auth_flow.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/extensions/api/identity/web_auth_flow.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/base64.h"
@@ -95,7 +96,7 @@ void WebAuthFlow::Start() {
     args->AppendString("silent");
 
   auto event =
-      base::MakeUnique<Event>(events::IDENTITY_PRIVATE_ON_WEB_FLOW_REQUEST,
+      std::make_unique<Event>(events::IDENTITY_PRIVATE_ON_WEB_FLOW_REQUEST,
                               identity_private::OnWebFlowRequest::kEventName,
                               std::move(args), profile_);
   ExtensionSystem* system = ExtensionSystem::Get(profile_);
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.cc b/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.cc
index b28d8c9221e..793a0a5d6b2 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.cc
@@ -8,6 +8,7 @@
 #include "chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
 #include "content/public/browser/browser_thread.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -19,10 +20,15 @@ const int kPartitionTableSize = 2 * 4096;
 
 DestroyPartitionsOperation::DestroyPartitionsOperation(
     base::WeakPtr<OperationManager> manager,
+    std::unique_ptr<service_manager::Connector> connector,
     const ExtensionId& extension_id,
     const std::string& storage_unit_id,
     const base::FilePath& download_folder)
-    : Operation(manager, extension_id, storage_unit_id, download_folder) {}
+    : Operation(manager,
+                std::move(connector),
+                extension_id,
+                storage_unit_id,
+                download_folder) {}
 
 DestroyPartitionsOperation::~DestroyPartitionsOperation() {}
 
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h b/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h
index 30b7a961015..3373953c3e6 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h
@@ -17,10 +17,12 @@ extern const int kPartitionTableSize;
 // creating a dummy blank image which is then burned to the disk.
 class DestroyPartitionsOperation : public Operation {
  public:
-  DestroyPartitionsOperation(base::WeakPtr<OperationManager> manager,
-                             const ExtensionId& extension_id,
-                             const std::string& storage_unit_id,
-                             const base::FilePath& download_folder);
+  DestroyPartitionsOperation(
+      base::WeakPtr<OperationManager> manager,
+      std::unique_ptr<service_manager::Connector> connector,
+      const ExtensionId& extension_id,
+      const std::string& storage_unit_id,
+      const base::FilePath& download_folder);
   void StartImpl() override;
 
  private:
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation_unittest.cc b/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation_unittest.cc
index bf12417a6e6..28854cf8077 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation_unittest.cc
@@ -2,12 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
-#include "chrome/browser/extensions/api/image_writer_private/destroy_partitions_operation.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
 #include "chrome/test/base/testing_profile.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -41,7 +42,7 @@ TEST_F(ImageWriterDestroyPartitionsOperationTest, EndToEnd) {
   scoped_refptr<DestroyPartitionsOperation> operation(
       new DestroyPartitionsOperation(
           manager.AsWeakPtr(),
-          kDummyExtensionId,
+          /*connector=*/nullptr, kDummyExtensionId,
           test_utils_.GetDevicePath().AsUTF8Unsafe(),
           base::FilePath(FILE_PATH_LITERAL("/var/tmp"))));
 
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.cc b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.cc
index c099e6c9a89..7d81d3c4a6e 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.cc
@@ -10,11 +10,11 @@
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/threading/thread_restrictions.h"
-#include "chrome/common/extensions/removable_storage_writer.mojom.h"
 #include "chrome/grit/generated_resources.h"
+#include "chrome/services/removable_storage_writer/public/interfaces/constants.mojom.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/utility_process_mojo_client.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
@@ -23,20 +23,24 @@ namespace image_writer {
 namespace {
 ImageWriterUtilityClient::ImageWriterUtilityClientFactory*
     g_factory_for_testing = nullptr;
+
+void DeleteInterfacePtr(chrome::mojom::RemovableStorageWriterPtr writer_ptr) {
+  // Just let the parameters go out of scope so they are deleted.
+}
 }  // namespace
 
 class ImageWriterUtilityClient::RemovableStorageWriterClientImpl
-    : public extensions::mojom::RemovableStorageWriterClient {
+    : public chrome::mojom::RemovableStorageWriterClient {
  public:
   RemovableStorageWriterClientImpl(
       ImageWriterUtilityClient* owner,
-      extensions::mojom::RemovableStorageWriterClientPtr* interface)
+      chrome::mojom::RemovableStorageWriterClientPtr* interface)
       : binding_(this, mojo::MakeRequest(interface)),
         image_writer_utility_client_(owner) {
     base::AssertBlockingAllowed();
 
     binding_.set_connection_error_handler(
-        base::BindOnce(&ImageWriterUtilityClient::UtilityProcessError,
+        base::BindOnce(&ImageWriterUtilityClient::OnConnectionError,
                        image_writer_utility_client_));
   }
 
@@ -55,22 +59,37 @@ class ImageWriterUtilityClient::RemovableStorageWriterClientImpl
     }
   }
 
-  mojo::Binding<extensions::mojom::RemovableStorageWriterClient> binding_;
+  mojo::Binding<chrome::mojom::RemovableStorageWriterClient> binding_;
   // |image_writer_utility_client_| owns |this|.
   ImageWriterUtilityClient* const image_writer_utility_client_;
 
   DISALLOW_COPY_AND_ASSIGN(RemovableStorageWriterClientImpl);
 };
 
-ImageWriterUtilityClient::ImageWriterUtilityClient() = default;
-
-ImageWriterUtilityClient::~ImageWriterUtilityClient() = default;
+ImageWriterUtilityClient::ImageWriterUtilityClient(
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+    std::unique_ptr<service_manager::Connector> connector)
+    : task_runner_(task_runner), connector_(std::move(connector)) {}
+
+ImageWriterUtilityClient::~ImageWriterUtilityClient() {
+  // We could be running on a different TaskRunner (typically, the UI thread).
+  // Post to be safe.
+  task_runner_->DeleteSoon(FROM_HERE, std::move(connector_));
+  task_runner_->PostTask(FROM_HERE,
+                         base::BindOnce(&DeleteInterfacePtr,
+                                        std::move(removable_storage_writer_)));
+}
 
 // static
-scoped_refptr<ImageWriterUtilityClient> ImageWriterUtilityClient::Create() {
+scoped_refptr<ImageWriterUtilityClient> ImageWriterUtilityClient::Create(
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+    std::unique_ptr<service_manager::Connector> connector) {
+  // connector_ can be null in unit-tests.
+  DCHECK(!connector || !connector->IsBound());
   if (g_factory_for_testing)
     return g_factory_for_testing->Run();
-  return base::WrapRefCounted(new ImageWriterUtilityClient());
+  return base::WrapRefCounted(
+      new ImageWriterUtilityClient(task_runner, std::move(connector)));
 }
 
 // static
@@ -91,14 +110,13 @@ void ImageWriterUtilityClient::Write(const ProgressCallback& progress_callback,
   success_callback_ = success_callback;
   error_callback_ = error_callback;
 
-  StartUtilityProcessIfNeeded();
+  BindServiceIfNeeded();
 
-  extensions::mojom::RemovableStorageWriterClientPtr client;
+  chrome::mojom::RemovableStorageWriterClientPtr client;
   removable_storage_writer_client_ =
-      base::MakeUnique<RemovableStorageWriterClientImpl>(this, &client);
+      std::make_unique<RemovableStorageWriterClientImpl>(this, &client);
 
-  utility_process_mojo_client_->service()->Write(source, target,
-                                                 std::move(client));
+  removable_storage_writer_->Write(source, target, std::move(client));
 }
 
 void ImageWriterUtilityClient::Verify(const ProgressCallback& progress_callback,
@@ -113,14 +131,13 @@ void ImageWriterUtilityClient::Verify(const ProgressCallback& progress_callback,
   success_callback_ = success_callback;
   error_callback_ = error_callback;
 
-  StartUtilityProcessIfNeeded();
+  BindServiceIfNeeded();
 
-  extensions::mojom::RemovableStorageWriterClientPtr client;
+  chrome::mojom::RemovableStorageWriterClientPtr client;
   removable_storage_writer_client_ =
-      base::MakeUnique<RemovableStorageWriterClientImpl>(this, &client);
+      std::make_unique<RemovableStorageWriterClientImpl>(this, &client);
 
-  utility_process_mojo_client_->service()->Verify(source, target,
-                                                  std::move(client));
+  removable_storage_writer_->Verify(source, target, std::move(client));
 }
 
 void ImageWriterUtilityClient::Cancel(const CancelCallback& cancel_callback) {
@@ -135,35 +152,27 @@ void ImageWriterUtilityClient::Shutdown() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   ResetRequest();
-  utility_process_mojo_client_.reset();
+  removable_storage_writer_.reset();
 }
 
-void ImageWriterUtilityClient::StartUtilityProcessIfNeeded() {
+void ImageWriterUtilityClient::BindServiceIfNeeded() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  if (utility_process_mojo_client_)
+  if (removable_storage_writer_)
     return;
 
-  utility_process_mojo_client_ =
-      base::MakeUnique<content::UtilityProcessMojoClient<
-          extensions::mojom::RemovableStorageWriter>>(
-          l10n_util::GetStringUTF16(IDS_UTILITY_PROCESS_IMAGE_WRITER_NAME));
-  utility_process_mojo_client_->set_error_callback(
-      base::Bind(&ImageWriterUtilityClient::UtilityProcessError, this));
-
-  utility_process_mojo_client_->set_disable_sandbox();
-#if defined(OS_WIN)
-  utility_process_mojo_client_->set_run_elevated();
-#endif
-
-  utility_process_mojo_client_->Start();
+  connector_->BindInterface(chrome::mojom::kRemovableStorageWriterServiceName,
+                            mojo::MakeRequest(&removable_storage_writer_));
+  removable_storage_writer_.set_connection_error_handler(
+      base::Bind(&ImageWriterUtilityClient::OnConnectionError, this));
 }
 
-void ImageWriterUtilityClient::UtilityProcessError() {
+void ImageWriterUtilityClient::OnConnectionError() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  OperationFailed("Utility process crashed or failed.");
-  utility_process_mojo_client_.reset();
+  OperationFailed(
+      "Error with the connection to the RemovableStorageWriter service.");
+  removable_storage_writer_.reset();
 }
 
 void ImageWriterUtilityClient::OperationProgress(int64_t progress) {
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.h b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.h
index 183c07357d6..3ab0136b017 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.h
@@ -7,13 +7,19 @@
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequence_checker.h"
-#include "chrome/common/extensions/removable_storage_writer.mojom.h"
-#include "content/public/browser/utility_process_mojo_client.h"
+#include "base/sequenced_task_runner.h"
+#include "chrome/services/removable_storage_writer/public/interfaces/removable_storage_writer.mojom.h"
+
+namespace service_manager {
+class Connector;
+}
 
 namespace extensions {
 namespace image_writer {
@@ -30,7 +36,10 @@ class ImageWriterUtilityClient
   using ImageWriterUtilityClientFactory =
       base::Callback<scoped_refptr<ImageWriterUtilityClient>()>;
 
-  static scoped_refptr<ImageWriterUtilityClient> Create();
+  // |connector| should be a fresh connector not yet bound to any thread.
+  static scoped_refptr<ImageWriterUtilityClient> Create(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+      std::unique_ptr<service_manager::Connector> connector);
 
   static void SetFactoryForTesting(ImageWriterUtilityClientFactory* factory);
 
@@ -70,14 +79,16 @@ class ImageWriterUtilityClient
   friend class base::RefCountedThreadSafe<ImageWriterUtilityClient>;
   friend class ImageWriterUtilityClientTest;
 
-  ImageWriterUtilityClient();
+  ImageWriterUtilityClient(
+      const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+      std::unique_ptr<service_manager::Connector> connector);
   virtual ~ImageWriterUtilityClient();
 
  private:
   class RemovableStorageWriterClientImpl;
 
-  void StartUtilityProcessIfNeeded();
-  void UtilityProcessError();
+  void BindServiceIfNeeded();
+  void OnConnectionError();
 
   void OperationProgress(int64_t progress);
   void OperationSucceeded();
@@ -89,9 +100,11 @@ class ImageWriterUtilityClient
   SuccessCallback success_callback_;
   ErrorCallback error_callback_;
 
-  std::unique_ptr<content::UtilityProcessMojoClient<
-      extensions::mojom::RemovableStorageWriter>>
-      utility_process_mojo_client_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  std::unique_ptr<service_manager::Connector> connector_;
+
+  chrome::mojom::RemovableStorageWriterPtr removable_storage_writer_;
 
   std::unique_ptr<RemovableStorageWriterClientImpl>
       removable_storage_writer_client_;
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client_browsertest.cc b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client_browsertest.cc
index 7dc73395bb7..68e923f6766 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_utility_client_browsertest.cc
@@ -15,9 +15,11 @@
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
-#include "chrome/common/extensions/removable_storage_writer.mojom.h"
+#include "chrome/services/removable_storage_writer/public/interfaces/removable_storage_writer.mojom.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/common/service_manager_connection.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -31,7 +33,7 @@ class ImageWriterUtilityClientTest : public InProcessBrowserTest {
   ImageWriterUtilityClientTest() {
     base::ScopedAllowBlockingForTesting allow_blocking;
     test_device_ = base::FilePath().AppendASCII(
-        extensions::mojom::RemovableStorageWriter::kTestDevice);
+        chrome::mojom::RemovableStorageWriter::kTestDevice);
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
@@ -97,11 +99,18 @@ class ImageWriterUtilityClientTest : public InProcessBrowserTest {
   const std::string& error() const { return error_; }
 
  private:
+  void SetUpOnMainThread() override {
+    connector_ = content::ServiceManagerConnection::GetForProcess()
+                     ->GetConnector()
+                     ->Clone();
+  }
+
   void StartWriteTest() {
     DCHECK(IsRunningInCorrectSequence());
 
     if (!image_writer_utility_client_)
-      image_writer_utility_client_ = new ImageWriterUtilityClient();
+      image_writer_utility_client_ =
+          new ImageWriterUtilityClient(GetTaskRunner(), std::move(connector_));
     success_ = false;
     progress_ = 0;
 
@@ -147,7 +156,8 @@ class ImageWriterUtilityClientTest : public InProcessBrowserTest {
     DCHECK(IsRunningInCorrectSequence());
 
     if (!image_writer_utility_client_)
-      image_writer_utility_client_ = new ImageWriterUtilityClient();
+      image_writer_utility_client_ =
+          new ImageWriterUtilityClient(GetTaskRunner(), std::move(connector_));
     success_ = false;
     progress_ = 0;
 
@@ -245,6 +255,7 @@ class ImageWriterUtilityClientTest : public InProcessBrowserTest {
   bool cancel_ = false;
   std::string error_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
+  std::unique_ptr<service_manager::Connector> connector_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageWriterUtilityClientTest);
 };
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/operation.cc b/chromium/chrome/browser/extensions/api/image_writer_private/operation.cc
index 8eb89543b48..8c89c0334bb 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation.cc
@@ -14,6 +14,7 @@
 #include "chrome/browser/extensions/api/image_writer_private/operation_manager.h"
 #include "chrome/browser/extensions/api/image_writer_private/unzip_helper.h"
 #include "content/public/browser/browser_thread.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -27,6 +28,7 @@ const int kMD5BufferSize = 1024;
 }  // namespace
 
 Operation::Operation(base::WeakPtr<OperationManager> manager,
+                     std::unique_ptr<service_manager::Connector> connector,
                      const ExtensionId& extension_id,
                      const std::string& device_path,
                      const base::FilePath& download_folder)
@@ -37,6 +39,7 @@ Operation::Operation(base::WeakPtr<OperationManager> manager,
 #else
       device_path_(device_path),
 #endif
+      connector_(std::move(connector)),
       stage_(image_writer_api::STAGE_UNKNOWN),
       progress_(0),
       download_folder_(download_folder),
@@ -44,7 +47,10 @@ Operation::Operation(base::WeakPtr<OperationManager> manager,
           base::CreateSequencedTaskRunnerWithTraits(blocking_task_traits())) {
 }
 
-Operation::~Operation() {}
+Operation::~Operation() {
+  // The connector_ is bound to the |task_runner_| and must be deleted there.
+  task_runner_->DeleteSoon(FROM_HERE, std::move(connector_));
+}
 
 void Operation::Cancel() {
   DCHECK(IsRunningInCorrectSequence());
@@ -192,7 +198,9 @@ void Operation::CompleteAndContinue(const base::Closure& continuation) {
 void Operation::StartUtilityClient() {
   DCHECK(IsRunningInCorrectSequence());
   if (!image_writer_client_.get()) {
-    image_writer_client_ = ImageWriterUtilityClient::Create();
+    // connector_ can be null in tests.
+    image_writer_client_ = ImageWriterUtilityClient::Create(
+        task_runner_, connector_ ? connector_->Clone() : nullptr);
     AddCleanUpFunction(base::BindOnce(&Operation::StopUtilityClient, this));
   }
 }
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/operation.h b/chromium/chrome/browser/extensions/api/image_writer_private/operation.h
index 29144f7386f..f629f58d7e4 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation.h
@@ -28,6 +28,10 @@ namespace base {
 class FilePath;
 }  // namespace base
 
+namespace service_manager {
+class Connector;
+}
+
 namespace extensions {
 namespace image_writer {
 
@@ -59,6 +63,7 @@ class Operation : public base::RefCountedThreadSafe<Operation> {
       base::OnceCallback<void(bool, const std::string&)>;
 
   Operation(base::WeakPtr<OperationManager> manager,
+            std::unique_ptr<service_manager::Connector> connector,
             const ExtensionId& extension_id,
             const std::string& device_path,
             const base::FilePath& download_folder);
@@ -209,6 +214,9 @@ class Operation : public base::RefCountedThreadSafe<Operation> {
   // Runs all cleanup functions.
   void CleanUp();
 
+  // Connector to the service manager. Used and deleted on |task_runner_|.
+  std::unique_ptr<service_manager::Connector> connector_;
+
   // |stage_| and |progress_| are owned by the FILE thread, use |SetStage| and
   // |SetProgress| to update.  Progress should be in the interval [0,100]
   image_writer_api::Stage stage_;
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.cc b/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.cc
index 10dcad0f29e..f923cc582c0 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.cc
@@ -20,10 +20,12 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/storage_partition.h"
+#include "content/public/common/service_manager_connection.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/notification_types.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/file_manager/path_util.h"
@@ -85,14 +87,10 @@ void OperationManager::StartWriteFromUrl(
   }
 
   scoped_refptr<Operation> operation(new WriteFromUrlOperation(
-      weak_factory_.GetWeakPtr(),
-      extension_id,
-      content::BrowserContext::GetDefaultStoragePartition(browser_context_)->
-          GetURLRequestContext(),
-      url,
-      hash,
-      device_path,
-      GetAssociatedDownloadFolder()));
+      weak_factory_.GetWeakPtr(), CreateConnector(), extension_id,
+      content::BrowserContext::GetDefaultStoragePartition(browser_context_)
+          ->GetURLRequestContext(),
+      url, hash, device_path, GetAssociatedDownloadFolder()));
   operations_[extension_id] = operation;
   operation->PostTask(base::BindOnce(&Operation::Start, operation));
 
@@ -117,8 +115,8 @@ void OperationManager::StartWriteFromFile(
   }
 
   scoped_refptr<Operation> operation(new WriteFromFileOperation(
-      weak_factory_.GetWeakPtr(), extension_id, path, device_path,
-      GetAssociatedDownloadFolder()));
+      weak_factory_.GetWeakPtr(), CreateConnector(), extension_id, path,
+      device_path, GetAssociatedDownloadFolder()));
   operations_[extension_id] = operation;
   operation->PostTask(base::BindOnce(&Operation::Start, operation));
   std::move(callback).Run(true, "");
@@ -150,7 +148,7 @@ void OperationManager::DestroyPartitions(
   }
 
   scoped_refptr<Operation> operation(new DestroyPartitionsOperation(
-      weak_factory_.GetWeakPtr(), extension_id, device_path,
+      weak_factory_.GetWeakPtr(), CreateConnector(), extension_id, device_path,
       GetAssociatedDownloadFolder()));
   operations_[extension_id] = operation;
   operation->PostTask(base::BindOnce(&Operation::Start, operation));
@@ -245,6 +243,13 @@ void OperationManager::OnExtensionUnloaded(
   DeleteOperation(extension->id());
 }
 
+std::unique_ptr<service_manager::Connector>
+OperationManager::CreateConnector() {
+  return content::ServiceManagerConnection::GetForProcess()
+      ->GetConnector()
+      ->Clone();
+}
+
 void OperationManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.h b/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.h
index 9debbffd6f8..48abcac2426 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager.h
@@ -86,6 +86,10 @@ class OperationManager : public BrowserContextKeyedAPI,
   static BrowserContextKeyedAPIFactory<OperationManager>* GetFactoryInstance();
   static OperationManager* Get(content::BrowserContext* context);
 
+ protected:
+  // Overridden in test.
+  virtual std::unique_ptr<service_manager::Connector> CreateConnector();
+
  private:
   static const char* service_name() {
     return "OperationManager";
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager_unittest.cc b/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager_unittest.cc
index 22f6193100d..45ae891cf8f 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation_manager_unittest.cc
@@ -13,12 +13,24 @@
 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
 #include "chrome/test/base/testing_profile.h"
 #include "extensions/browser/test_event_router.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
 
 namespace {
 
+class TestOperationManager : public OperationManager {
+ public:
+  explicit TestOperationManager(content::BrowserContext* context)
+      : OperationManager(context) {}
+
+ private:
+  std::unique_ptr<service_manager::Connector> CreateConnector() override {
+    return nullptr;
+  }
+};
+
 class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
  public:
   void StartCallback(bool success, const std::string& error) {
@@ -56,7 +68,7 @@ class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
 };
 
 TEST_F(ImageWriterOperationManagerTest, WriteFromFile) {
-  OperationManager manager(&test_profile_);
+  TestOperationManager manager(&test_profile_);
 
   manager.StartWriteFromFile(
       kDummyExtensionId,
@@ -82,7 +94,7 @@ TEST_F(ImageWriterOperationManagerTest, WriteFromFile) {
 }
 
 TEST_F(ImageWriterOperationManagerTest, DestroyPartitions) {
-  OperationManager manager(&test_profile_);
+  TestOperationManager manager(&test_profile_);
 
   manager.DestroyPartitions(
       kDummyExtensionId,
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/operation_unittest.cc b/chromium/chrome/browser/extensions/api/image_writer_private/operation_unittest.cc
index f2f030df622..fcff500fa4c 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation_unittest.cc
@@ -2,18 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome/browser/extensions/api/image_writer_private/operation.h"
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
-#include "chrome/browser/extensions/api/image_writer_private/operation.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation_manager.h"
 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/google/zip.h"
@@ -50,7 +52,11 @@ class OperationForTest : public Operation {
                    const ExtensionId& extension_id,
                    const std::string& device_path,
                    const base::FilePath& download_path)
-      : Operation(manager_, extension_id, device_path, download_path) {}
+      : Operation(manager_,
+                  /*connector=*/nullptr,
+                  extension_id,
+                  device_path,
+                  download_path) {}
 
   void StartImpl() override {}
 
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_win.cc b/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_win.cc
index 51db3d51b8d..f7272b5f809 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_win.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider_win.cc
@@ -149,7 +149,7 @@ bool AddDeviceInfo(HANDLE interface_enumerator,
   }
 
   std::string drive_id = "\\\\.\\PhysicalDrive";
-  drive_id.append(base::Uint64ToString(device_number.DeviceNumber));
+  drive_id.append(base::NumberToString(device_number.DeviceNumber));
 
   api::image_writer_private::RemovableStorageDevice device;
   device.capacity = disk_capacity;
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.cc b/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.cc
index 432640c08fb..d8204d5ad57 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.cc
@@ -9,9 +9,11 @@
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ -86,7 +88,12 @@ SimulateProgressInfo::~SimulateProgressInfo() {}
 SimulateProgressInfo::SimulateProgressInfo(const SimulateProgressInfo&) =
     default;
 
-FakeImageWriterClient::FakeImageWriterClient() {}
+FakeImageWriterClient::FakeImageWriterClient()
+    : ImageWriterUtilityClient(
+          base::CreateSequencedTaskRunnerWithTraits(
+              {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+               base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}),
+          /*connector=*/nullptr) {}
 FakeImageWriterClient::~FakeImageWriterClient() {}
 
 void FakeImageWriterClient::SimulateProgressAndCompletion(
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.h b/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.h
index 8ad775dbb06..4e3ed443001 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/test_utils.h
@@ -7,6 +7,8 @@
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/unzip_helper.cc b/chromium/chrome/browser/extensions/api/image_writer_private/unzip_helper.cc
index 39f27d646ad..e6c03d00fee 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/unzip_helper.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/unzip_helper.cc
@@ -4,8 +4,9 @@
 
 #include "chrome/browser/extensions/api/image_writer_private/unzip_helper.h"
 
+#include <memory>
+
 #include "base/files/file_util.h"
-#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
@@ -25,7 +26,7 @@ UnzipHelper::UnzipHelper(
       complete_callback_(complete_callback),
       failure_callback_(failure_callback),
       progress_callback_(progress_callback),
-      zip_reader_(base::MakeUnique<zip::ZipReader>()) {}
+      zip_reader_(std::make_unique<zip::ZipReader>()) {}
 
 UnzipHelper::~UnzipHelper() {}
 
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.cc b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.cc
index cc9ff46059d..451f0f4a4b5 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.cc
@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h"
+
 #include "base/files/file_util.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
-#include "chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h"
 #include "content/public/browser/browser_thread.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -14,11 +16,16 @@ using content::BrowserThread;
 
 WriteFromFileOperation::WriteFromFileOperation(
     base::WeakPtr<OperationManager> manager,
+    std::unique_ptr<service_manager::Connector> connector,
     const ExtensionId& extension_id,
     const base::FilePath& user_file_path,
     const std::string& device_path,
     const base::FilePath& download_folder)
-    : Operation(manager, extension_id, device_path, download_folder) {
+    : Operation(manager,
+                std::move(connector),
+                extension_id,
+                device_path,
+                download_folder) {
   image_path_ = user_file_path;
 }
 
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h
index ef82e25f881..5e6951e2ff6 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h
@@ -7,6 +7,10 @@
 
 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
 
+namespace service_manager {
+class Connector;
+}
+
 namespace extensions {
 namespace image_writer {
 
@@ -14,6 +18,7 @@ namespace image_writer {
 class WriteFromFileOperation : public Operation {
  public:
   WriteFromFileOperation(base::WeakPtr<OperationManager> manager,
+                         std::unique_ptr<service_manager::Connector> connector,
                          const ExtensionId& extension_id,
                          const base::FilePath& user_file_path,
                          const std::string& storage_unit_id,
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation_unittest.cc b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation_unittest.cc
index e8a4f5a9209..2651caa8346 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_file_operation_unittest.cc
@@ -2,11 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h"
+
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
 #include "chrome/browser/extensions/api/image_writer_private/test_utils.h"
-#include "chrome/browser/extensions/api/image_writer_private/write_from_file_operation.h"
 #include "chrome/test/base/testing_profile.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -38,12 +40,11 @@ class ImageWriterFromFileTest : public ImageWriterUnitTestBase {
 };
 
 TEST_F(ImageWriterFromFileTest, InvalidFile) {
-  scoped_refptr<WriteFromFileOperation> op =
-      new WriteFromFileOperation(manager_.AsWeakPtr(),
-                                 kDummyExtensionId,
-                                 test_utils_.GetImagePath(),
-                                 test_utils_.GetDevicePath().AsUTF8Unsafe(),
-                                 base::FilePath(FILE_PATH_LITERAL("/var/tmp")));
+  scoped_refptr<WriteFromFileOperation> op = new WriteFromFileOperation(
+      manager_.AsWeakPtr(),
+      /*connector=*/nullptr, kDummyExtensionId, test_utils_.GetImagePath(),
+      test_utils_.GetDevicePath().AsUTF8Unsafe(),
+      base::FilePath(FILE_PATH_LITERAL("/var/tmp")));
 
   base::DeleteFile(test_utils_.GetImagePath(), false);
 
@@ -67,12 +68,11 @@ TEST_F(ImageWriterFromFileTest, WriteFromFileEndToEnd) {
       base::BindOnce(&SetUpImageWriteClientProgressSimulation));
 #endif
 
-  scoped_refptr<WriteFromFileOperation> op =
-      new WriteFromFileOperation(manager_.AsWeakPtr(),
-                                 kDummyExtensionId,
-                                 test_utils_.GetImagePath(),
-                                 test_utils_.GetDevicePath().AsUTF8Unsafe(),
-                                 base::FilePath(FILE_PATH_LITERAL("/var/tmp")));
+  scoped_refptr<WriteFromFileOperation> op = new WriteFromFileOperation(
+      manager_.AsWeakPtr(),
+      /*connector=*/nullptr, kDummyExtensionId, test_utils_.GetImagePath(),
+      test_utils_.GetDevicePath().AsUTF8Unsafe(),
+      base::FilePath(FILE_PATH_LITERAL("/var/tmp")));
   EXPECT_CALL(manager_,
               OnProgress(kDummyExtensionId, image_writer_api::STAGE_WRITE, _))
       .Times(AnyNumber());
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.cc b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.cc
index ca700e12d9c..cedfb9b5446 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.cc
@@ -9,6 +9,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "net/url_request/url_fetcher.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -17,20 +18,24 @@ using content::BrowserThread;
 
 WriteFromUrlOperation::WriteFromUrlOperation(
     base::WeakPtr<OperationManager> manager,
+    std::unique_ptr<service_manager::Connector> connector,
     const ExtensionId& extension_id,
     net::URLRequestContextGetter* request_context,
     GURL url,
     const std::string& hash,
     const std::string& device_path,
     const base::FilePath& download_folder)
-    : Operation(manager, extension_id, device_path, download_folder),
+    : Operation(manager,
+                std::move(connector),
+                extension_id,
+                device_path,
+                download_folder),
       request_context_(request_context),
       url_(url),
       hash_(hash),
       download_continuation_() {}
 
-WriteFromUrlOperation::~WriteFromUrlOperation() {
-}
+WriteFromUrlOperation::~WriteFromUrlOperation() = default;
 
 void WriteFromUrlOperation::StartImpl() {
   DCHECK(IsRunningInCorrectSequence());
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.h b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.h
index 47c98f8e06d..b2c5a9cfa9b 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation.h
@@ -25,6 +25,7 @@ class OperationManager;
 class WriteFromUrlOperation : public Operation, public net::URLFetcherDelegate {
  public:
   WriteFromUrlOperation(base::WeakPtr<OperationManager> manager,
+                        std::unique_ptr<service_manager::Connector> connector,
                         const ExtensionId& extension_id,
                         net::URLRequestContextGetter* request_context,
                         GURL url,
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation_unittest.cc b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation_unittest.cc
index a8b7a3f3b04..e1787976314 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/write_from_url_operation_unittest.cc
@@ -11,6 +11,7 @@
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/test_url_request_interceptor.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 namespace extensions {
 namespace image_writer {
@@ -41,6 +42,7 @@ class WriteFromUrlOperationForTest : public WriteFromUrlOperation {
                                const std::string& hash,
                                const std::string& storage_unit_id)
       : WriteFromUrlOperation(manager,
+                              /*connector=*/nullptr,
                               extension_id,
                               request_context,
                               url,
diff --git a/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.cc b/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.cc
index f9456d8298f..efd57030204 100644
--- a/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.cc
+++ b/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.cc
@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "content/public/browser/notification_registrar.h"
@@ -332,12 +331,12 @@ ExtensionFunction::ResponseAction InputImeSetCompositionFunction::Run() {
                                 selection_start, selection_end, params.cursor,
                                 segments, &error)) {
       std::unique_ptr<base::ListValue> results =
-          base::MakeUnique<base::ListValue>();
-      results->Append(base::MakeUnique<base::Value>(false));
+          std::make_unique<base::ListValue>();
+      results->Append(std::make_unique<base::Value>(false));
       return RespondNow(ErrorWithArguments(std::move(results), error));
     }
   }
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
 }
 
 ExtensionFunction::ResponseAction InputImeCommitTextFunction::Run() {
@@ -352,12 +351,12 @@ ExtensionFunction::ResponseAction InputImeCommitTextFunction::Run() {
     std::string error;
     if (!engine->CommitText(params.context_id, params.text.c_str(), &error)) {
       std::unique_ptr<base::ListValue> results =
-          base::MakeUnique<base::ListValue>();
-      results->Append(base::MakeUnique<base::Value>(false));
+          std::make_unique<base::ListValue>();
+      results->Append(std::make_unique<base::Value>(false));
       return RespondNow(ErrorWithArguments(std::move(results), error));
     }
   }
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
 }
 
 ExtensionFunction::ResponseAction InputImeSendKeyEventsFunction::Run() {
diff --git a/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc b/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc
index dedf48b0078..f9f3e2969dc 100644
--- a/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc
+++ b/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.cc
@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
@@ -25,8 +24,8 @@
 #include "ui/base/ime/chromeos/extension_ime_util.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 #include "ui/base/ime/ime_engine_handler_interface.h"
+#include "ui/keyboard/content/keyboard_content_util.h"
 #include "ui/keyboard/keyboard_controller.h"
-#include "ui/keyboard/keyboard_util.h"
 
 namespace input_ime = extensions::api::input_ime;
 namespace DeleteSurroundingText =
@@ -164,9 +163,9 @@ class ImeObserverChromeOS : public ui::ImeObserver {
       return;
 
     // Note: this is a private API event.
-    auto bounds_list = base::MakeUnique<base::ListValue>();
+    auto bounds_list = std::make_unique<base::ListValue>();
     for (size_t i = 0; i < bounds.size(); ++i) {
-      auto bounds_value = base::MakeUnique<base::DictionaryValue>();
+      auto bounds_value = std::make_unique<base::DictionaryValue>();
       bounds_value->SetInteger("x", bounds[i].x());
       bounds_value->SetInteger("y", bounds[i].y());
       bounds_value->SetInteger("w", bounds[i].width());
@@ -198,7 +197,7 @@ class ImeObserverChromeOS : public ui::ImeObserver {
       std::unique_ptr<base::ListValue> args) override {
     if (event_name == input_ime::OnActivate::kEventName) {
       // Send onActivate event regardless of it's listened by the IME.
-      auto event = base::MakeUnique<extensions::Event>(
+      auto event = std::make_unique<extensions::Event>(
           histogram_value, event_name, std::move(args), profile_);
       extensions::EventRouter::Get(profile_)->DispatchEventWithLazyListener(
           extension_id_, std::move(event));
@@ -226,7 +225,7 @@ class ImeObserverChromeOS : public ui::ImeObserver {
       }
     }
 
-    auto event = base::MakeUnique<extensions::Event>(
+    auto event = std::make_unique<extensions::Event>(
         histogram_value, event_name, std::move(args), profile_);
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, std::move(event));
@@ -371,7 +370,7 @@ ExtensionFunction::ResponseAction InputImeClearCompositionFunction::Run() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>(false)));
+    return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
   }
 
   std::unique_ptr<ClearComposition::Params> parent_params(
@@ -382,8 +381,8 @@ ExtensionFunction::ResponseAction InputImeClearCompositionFunction::Run() {
   std::string error;
   bool success = engine->ClearComposition(params.context_id, &error);
   std::unique_ptr<base::ListValue> results =
-      base::MakeUnique<base::ListValue>();
-  results->Append(base::MakeUnique<base::Value>(success));
+      std::make_unique<base::ListValue>();
+  results->Append(std::make_unique<base::Value>(success));
   return RespondNow(success ? ArgumentList(std::move(results))
                             : ErrorWithArguments(std::move(results), error));
 }
@@ -411,7 +410,7 @@ InputImeSetCandidateWindowPropertiesFunction::Run() {
       event_router ? event_router->GetEngine(extension_id(), params.engine_id)
                    : nullptr;
   if (!engine) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>(false)));
+    return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
   }
 
   const SetCandidateWindowProperties::Params::Parameters::Properties&
@@ -421,8 +420,8 @@ InputImeSetCandidateWindowPropertiesFunction::Run() {
   if (properties.visible &&
       !engine->SetCandidateWindowVisible(*properties.visible, &error)) {
     std::unique_ptr<base::ListValue> results =
-        base::MakeUnique<base::ListValue>();
-    results->Append(base::MakeUnique<base::Value>(false));
+        std::make_unique<base::ListValue>();
+    results->Append(std::make_unique<base::Value>(false));
     return RespondNow(ErrorWithArguments(std::move(results), error));
   }
 
@@ -468,14 +467,14 @@ InputImeSetCandidateWindowPropertiesFunction::Run() {
     engine->SetCandidateWindowProperty(properties_out);
   }
 
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
 }
 
 ExtensionFunction::ResponseAction InputImeSetCandidatesFunction::Run() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+    return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
   }
 
   std::unique_ptr<SetCandidates::Params> parent_params(
@@ -502,8 +501,8 @@ ExtensionFunction::ResponseAction InputImeSetCandidatesFunction::Run() {
   bool success =
       engine->SetCandidates(params.context_id, candidates_out, &error);
   std::unique_ptr<base::ListValue> results =
-      base::MakeUnique<base::ListValue>();
-  results->Append(base::MakeUnique<base::Value>(success));
+      std::make_unique<base::ListValue>();
+  results->Append(std::make_unique<base::Value>(success));
   return RespondNow(success ? ArgumentList(std::move(results))
                             : ErrorWithArguments(std::move(results), error));
 }
@@ -512,7 +511,7 @@ ExtensionFunction::ResponseAction InputImeSetCursorPositionFunction::Run() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>(false)));
+    return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
   }
 
   std::unique_ptr<SetCursorPosition::Params> parent_params(
@@ -524,8 +523,8 @@ ExtensionFunction::ResponseAction InputImeSetCursorPositionFunction::Run() {
   bool success =
       engine->SetCursorPosition(params.context_id, params.candidate_id, &error);
   std::unique_ptr<base::ListValue> results =
-      base::MakeUnique<base::ListValue>();
-  results->Append(base::MakeUnique<base::Value>(success));
+      std::make_unique<base::ListValue>();
+  results->Append(std::make_unique<base::Value>(success));
   return RespondNow(success ? ArgumentList(std::move(results))
                             : ErrorWithArguments(std::move(results), error));
 }
diff --git a/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc b/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
index 03ea717539d..11bccc7e86d 100644
--- a/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
+++ b/chromium/chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc
@@ -10,9 +10,10 @@
 
 #include "chrome/browser/extensions/api/input_ime/input_ime_api.h"
 
+#include <memory>
+
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
@@ -114,7 +115,7 @@ class ImeObserverNonChromeOS : public ui::ImeObserver {
       return;
     }
 
-    auto event = base::MakeUnique<extensions::Event>(
+    auto event = std::make_unique<extensions::Event>(
         histogram_value, event_name, std::move(args), profile_);
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, std::move(event));
@@ -150,7 +151,7 @@ void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
   Profile* profile = Profile::FromBrowserContext(browser_context);
   ExtensionPrefs::Get(profile)->UpdateExtensionPref(
       extension->id(), kPrefNeverActivatedSinceLoaded,
-      base::MakeUnique<base::Value>(true));
+      std::make_unique<base::Value>(true));
 }
 
 void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
@@ -162,7 +163,7 @@ void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
     // Records the extension is not the last active IME engine.
     ExtensionPrefs::Get(Profile::FromBrowserContext(browser_context))
         ->UpdateExtensionPref(extension->id(), kPrefLastActiveEngine,
-                              base::MakeUnique<base::Value>(false));
+                              std::make_unique<base::Value>(false));
     event_router->DeleteInputMethodEngine(extension->id());
   }
 }
@@ -190,7 +191,7 @@ void InputImeEventRouter::SetActiveEngine(const std::string& extension_id) {
   // Records the extension is the last active IME engine.
   ExtensionPrefs::Get(GetProfile())
       ->UpdateExtensionPref(extension_id, kPrefLastActiveEngine,
-                            base::MakeUnique<base::Value>(true));
+                            std::make_unique<base::Value>(true));
   if (active_engine_) {
     if (active_engine_->GetExtensionId() == extension_id) {
       active_engine_->Enable(std::string());
@@ -201,7 +202,7 @@ void InputImeEventRouter::SetActiveEngine(const std::string& extension_id) {
     ExtensionPrefs::Get(GetProfile())
         ->UpdateExtensionPref(active_engine_->GetExtensionId(),
                               kPrefLastActiveEngine,
-                              base::MakeUnique<base::Value>(false));
+                              std::make_unique<base::Value>(false));
     DeleteInputMethodEngine(active_engine_->GetExtensionId());
   }
 
@@ -253,13 +254,13 @@ ExtensionFunction::ResponseAction InputImeActivateFunction::Run() {
     event_router->SetActiveEngine(extension_id());
     ExtensionPrefs::Get(profile)->UpdateExtensionPref(
         extension_id(), kPrefNeverActivatedSinceLoaded,
-        base::MakeUnique<base::Value>(false));
+        std::make_unique<base::Value>(false));
     return RespondNow(NoArguments());
   }
   // The API has already been called at least once.
   ExtensionPrefs::Get(profile)->UpdateExtensionPref(
       extension_id(), kPrefNeverActivatedSinceLoaded,
-      base::MakeUnique<base::Value>(false));
+      std::make_unique<base::Value>(false));
 
   // Otherwise, this API is only allowed to be called from a user action.
   if (!user_gesture())
@@ -321,7 +322,7 @@ void InputImeActivateFunction::OnPermissionBubbleFinished(
     // again' check box. So we can activate the extension directly next time.
     ExtensionPrefs::Get(profile)->UpdateExtensionPref(
         extension_id(), kPrefWarningBubbleNeverShow,
-        base::MakeUnique<base::Value>(true));
+        std::make_unique<base::Value>(true));
   }
 
   Respond(NoArguments());
@@ -379,7 +380,7 @@ ExtensionFunction::ResponseAction InputImeCreateWindowFunction::Run() {
     return RespondNow(Error(error));
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
-  result->Set("frameId", base::MakeUnique<base::Value>(frame_id));
+  result->Set("frameId", std::make_unique<base::Value>(frame_id));
 
   return RespondNow(OneArgument(std::move(result)));
 }
diff --git a/chromium/chrome/browser/extensions/api/instance_id/instance_id_api.cc b/chromium/chrome/browser/extensions/api/instance_id/instance_id_api.cc
index 0a897d47a7a..bb844a69c6c 100644
--- a/chromium/chrome/browser/extensions/api/instance_id/instance_id_api.cc
+++ b/chromium/chrome/browser/extensions/api/instance_id/instance_id_api.cc
@@ -4,8 +4,9 @@
 
 #include "chrome/browser/extensions/api/instance_id/instance_id_api.h"
 
+#include <memory>
+
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/gcm/instance_id/instance_id_profile_service.h"
 #include "chrome/browser/gcm/instance_id/instance_id_profile_service_factory.h"
@@ -95,7 +96,7 @@ ExtensionFunction::ResponseAction InstanceIDGetIDFunction::DoWork() {
 }
 
 void InstanceIDGetIDFunction::GetIDCompleted(const std::string& id) {
-  Respond(OneArgument(base::MakeUnique<base::Value>(id)));
+  Respond(OneArgument(std::make_unique<base::Value>(id)));
 }
 
 InstanceIDGetCreationTimeFunction::InstanceIDGetCreationTimeFunction() {}
@@ -112,7 +113,7 @@ ExtensionFunction::ResponseAction InstanceIDGetCreationTimeFunction::DoWork() {
 void InstanceIDGetCreationTimeFunction::GetCreationTimeCompleted(
     const base::Time& creation_time) {
   Respond(
-      OneArgument(base::MakeUnique<base::Value>(creation_time.ToDoubleT())));
+      OneArgument(std::make_unique<base::Value>(creation_time.ToDoubleT())));
 }
 
 InstanceIDGetTokenFunction::InstanceIDGetTokenFunction() {}
@@ -141,7 +142,7 @@ void InstanceIDGetTokenFunction::GetTokenCompleted(
     const std::string& token,
     instance_id::InstanceID::Result result) {
   if (result == instance_id::InstanceID::SUCCESS)
-    Respond(OneArgument(base::MakeUnique<base::Value>(token)));
+    Respond(OneArgument(std::make_unique<base::Value>(token)));
   else
     Respond(Error(InstanceIDResultToError(result)));
 }
diff --git a/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.cc b/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.cc
index 01046b0cdfc..e42d686bd00 100644
--- a/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.cc
@@ -13,7 +13,6 @@
 #include <vector>
 
 #include "base/feature_list.h"
-#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
@@ -156,8 +155,8 @@ std::vector<std::string> GetSortedExtensionIMEs(
   return extension_ime_list;
 }
 
-}  // anonymous namespace
-#endif
+}  // namespace
+#endif  // defined(OS_CHROMEOS)
 
 LanguageSettingsPrivateGetLanguageListFunction::
     LanguageSettingsPrivateGetLanguageListFunction()
@@ -184,8 +183,8 @@ LanguageSettingsPrivateGetLanguageListFunction::Run() {
                                                    locales.end());
 
   // Get the list of spell check languages and convert to a set.
-  std::vector<std::string> spellcheck_languages;
-  spellcheck::SpellCheckLanguages(&spellcheck_languages);
+  std::vector<std::string> spellcheck_languages =
+      spellcheck::SpellCheckLanguages();
   const std::unordered_set<std::string> spellcheck_language_set(
       spellcheck_languages.begin(), spellcheck_languages.end());
 
@@ -354,7 +353,9 @@ LanguageSettingsPrivateMoveLanguageFunction::Run() {
       NOTREACHED();
   }
 
-  translate_prefs->RearrangeLanguage(language_code, where,
+  // On Desktop we can only move languages by one position.
+  const int offset = 1;
+  translate_prefs->RearrangeLanguage(language_code, where, offset,
                                      supported_language_codes);
 
   return RespondNow(NoArguments());
@@ -445,7 +446,7 @@ LanguageSettingsPrivateAddSpellcheckWordFunction::Run() {
       SpellcheckServiceFactory::GetForContext(browser_context());
   bool success = service->GetCustomDictionary()->AddWord(params->word);
 
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(success)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(success)));
 }
 
 LanguageSettingsPrivateRemoveSpellcheckWordFunction::
@@ -464,7 +465,7 @@ LanguageSettingsPrivateRemoveSpellcheckWordFunction::Run() {
       SpellcheckServiceFactory::GetForContext(browser_context());
   bool success = service->GetCustomDictionary()->RemoveWord(params->word);
 
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(success)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(success)));
 }
 
 LanguageSettingsPrivateGetTranslateTargetLanguageFunction::
@@ -481,7 +482,7 @@ LanguageSettingsPrivateGetTranslateTargetLanguageFunction::Run() {
   language::LanguageModel* language_model =
       LanguageModelFactory::GetForBrowserContext(profile);
   return RespondNow(OneArgument(
-      base::MakeUnique<base::Value>(TranslateService::GetTargetLanguage(
+      std::make_unique<base::Value>(TranslateService::GetTargetLanguage(
           profile->GetPrefs(), language_model))));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/launcher_page/OWNERS b/chromium/chrome/browser/extensions/api/launcher_page/OWNERS
deleted file mode 100644
index ed54f09c40c..00000000000
--- a/chromium/chrome/browser/extensions/api/launcher_page/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-calamity@chromium.org
-khmel@chromium.org
diff --git a/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.cc b/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.cc
deleted file mode 100644
index 06c442350dd..00000000000
--- a/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.cc
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/browser/extensions/api/launcher_page/launcher_page_api.h"
-
-#include "ash/app_list/model/app_list_model.h"
-#include "base/lazy_instance.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/app_list/app_list_service.h"
-#include "chrome/browser/ui/app_list/app_list_syncable_service.h"
-#include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
-#include "chrome/common/extensions/api/launcher_page.h"
-#include "content/public/browser/web_contents.h"
-
-namespace extensions {
-
-static base::LazyInstance<BrowserContextKeyedAPIFactory<LauncherPageAPI>>::
-    DestructorAtExit g_launcher_api_factory = LAZY_INSTANCE_INITIALIZER;
-
-// static
-BrowserContextKeyedAPIFactory<LauncherPageAPI>*
-LauncherPageAPI::GetFactoryInstance() {
-  return g_launcher_api_factory.Pointer();
-}
-
-LauncherPageAPI::LauncherPageAPI(content::BrowserContext* context)
-    : service_(app_list::AppListSyncableServiceFactory::GetForProfile(
-          Profile::FromBrowserContext(context))) {
-}
-
-LauncherPageAPI::~LauncherPageAPI() {
-}
-
-app_list::AppListSyncableService* LauncherPageAPI::GetService() const {
-  return service_;
-}
-
-LauncherPagePushSubpageFunction::LauncherPagePushSubpageFunction() {
-}
-
-ExtensionFunction::ResponseAction LauncherPagePushSubpageFunction::Run() {
-  app_list::AppListSyncableService* service =
-      LauncherPageAPI::GetFactoryInstance()
-          ->Get(browser_context())
-          ->GetService();
-  app_list::AppListModel* model = service->GetModel();
-  model->PushCustomLauncherPageSubpage();
-
-  return RespondNow(NoArguments());
-}
-
-LauncherPageShowFunction::LauncherPageShowFunction() {
-}
-
-ExtensionFunction::ResponseAction LauncherPageShowFunction::Run() {
-  AppListService::Get()->ShowForCustomLauncherPage(
-      Profile::FromBrowserContext(browser_context()));
-
-  return RespondNow(NoArguments());
-}
-
-LauncherPageHideFunction::LauncherPageHideFunction() {
-}
-
-ExtensionFunction::ResponseAction LauncherPageHideFunction::Run() {
-  AppListService::Get()->HideCustomLauncherPage();
-
-  return RespondNow(NoArguments());
-}
-
-LauncherPageSetEnabledFunction::LauncherPageSetEnabledFunction() {
-}
-
-ExtensionFunction::ResponseAction LauncherPageSetEnabledFunction::Run() {
-  std::unique_ptr<api::launcher_page::SetEnabled::Params> params(
-      api::launcher_page::SetEnabled::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  app_list::AppListSyncableService* service =
-      LauncherPageAPI::GetFactoryInstance()
-          ->Get(browser_context())
-          ->GetService();
-  app_list::AppListModel* model = service->GetModel();
-  model->SetCustomLauncherPageEnabled(params->enabled);
-
-  return RespondNow(NoArguments());
-}
-
-}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.h b/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.h
deleted file mode 100644
index a1897fcceb6..00000000000
--- a/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.h
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CHROME_BROWSER_EXTENSIONS_API_LAUNCHER_PAGE_LAUNCHER_PAGE_API_H_
-#define CHROME_BROWSER_EXTENSIONS_API_LAUNCHER_PAGE_LAUNCHER_PAGE_API_H_
-
-#include "base/macros.h"
-#include "chrome/browser/extensions/chrome_extension_function.h"
-#include "extensions/browser/browser_context_keyed_api_factory.h"
-
-namespace app_list {
-class AppListSyncableService;
-}
-
-namespace extensions {
-
-class LauncherPageAPI : public BrowserContextKeyedAPI {
- public:
-  explicit LauncherPageAPI(content::BrowserContext* context);
-  ~LauncherPageAPI() override;
-
-  app_list::AppListSyncableService* GetService() const;
-  static BrowserContextKeyedAPIFactory<LauncherPageAPI>* GetFactoryInstance();
-
- private:
-  friend class BrowserContextKeyedAPIFactory<LauncherPageAPI>;
-
-  // BrowserContextKeyedAPI implementation.
-  static const char* service_name() { return "LauncherPageAPI"; }
-
-  static const bool kServiceHasOwnInstanceInIncognito = true;
-
-  app_list::AppListSyncableService* service_;
-};
-
-class LauncherPagePushSubpageFunction : public UIThreadExtensionFunction {
- public:
-  DECLARE_EXTENSION_FUNCTION("launcherPage.pushSubpage",
-                             LAUNCHERPAGE_PUSHSUBPAGE);
-
-  LauncherPagePushSubpageFunction();
-
- protected:
-  ~LauncherPagePushSubpageFunction() override {}
-
-  ResponseAction Run() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LauncherPagePushSubpageFunction);
-};
-
-class LauncherPageShowFunction : public UIThreadExtensionFunction {
- public:
-  DECLARE_EXTENSION_FUNCTION("launcherPage.show", LAUNCHERPAGE_SHOW);
-
-  LauncherPageShowFunction();
-
- protected:
-  ~LauncherPageShowFunction() override {}
-
-  ResponseAction Run() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LauncherPageShowFunction);
-};
-
-class LauncherPageHideFunction : public UIThreadExtensionFunction {
- public:
-  DECLARE_EXTENSION_FUNCTION("launcherPage.hide", LAUNCHERPAGE_HIDE);
-
-  LauncherPageHideFunction();
-
- protected:
-  ~LauncherPageHideFunction() override {}
-
-  ResponseAction Run() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LauncherPageHideFunction);
-};
-
-class LauncherPageSetEnabledFunction : public UIThreadExtensionFunction {
- public:
-  DECLARE_EXTENSION_FUNCTION("launcherPage.setEnabled",
-                             LAUNCHERPAGE_SETENABLED);
-
-  LauncherPageSetEnabledFunction();
-
- protected:
-  ~LauncherPageSetEnabledFunction() override {}
-
-  ResponseAction Run() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(LauncherPageSetEnabledFunction);
-};
-
-}  // namespace extensions
-
-#endif  // CHROME_BROWSER_EXTENSIONS_API_LAUNCHER_PAGE_LAUNCHER_PAGE_API_H_
diff --git a/chromium/chrome/browser/extensions/api/management/chrome_management_api_delegate.cc b/chromium/chrome/browser/extensions/api/management/chrome_management_api_delegate.cc
index ecebcd2a5ed..12e2e46e9c2 100644
--- a/chromium/chrome/browser/extensions/api/management/chrome_management_api_delegate.cc
+++ b/chromium/chrome/browser/extensions/api/management/chrome_management_api_delegate.cc
@@ -4,9 +4,10 @@
 
 #include "chrome/browser/extensions/api/management/chrome_management_api_delegate.h"
 
+#include <memory>
+
 #include "base/callback_helpers.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/bookmark_app_helper.h"
 #include "chrome/browser/extensions/chrome_extension_function_details.h"
@@ -32,10 +33,10 @@
 #include "content/public/common/service_manager_connection.h"
 #include "extensions/browser/api/management/management_api.h"
 #include "extensions/browser/api/management/management_api_constants.h"
+#include "extensions/browser/disable_reason.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
-#include "extensions/common/disable_reason.h"
 #include "extensions/common/extension.h"
 #include "services/data_decoder/public/cpp/safe_json_parser.h"
 
@@ -60,7 +61,7 @@ class ManagementSetEnabledFunctionInstallPromptDelegate
                        OnInstallPromptDone,
                    weak_factory_.GetWeakPtr()),
         extension, nullptr,
-        base::MakeUnique<ExtensionInstallPrompt::Prompt>(type),
+        std::make_unique<ExtensionInstallPrompt::Prompt>(type),
         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
   ~ManagementSetEnabledFunctionInstallPromptDelegate() override {}
@@ -149,7 +150,8 @@ class ChromeAppForLinkDelegate : public extensions::AppForLinkDelegate {
     }
 
     bookmark_app_helper_.reset(new extensions::BookmarkAppHelper(
-        Profile::FromBrowserContext(context), web_app, NULL));
+        Profile::FromBrowserContext(context), web_app, nullptr,
+        WebappInstallSource::MANAGEMENT_API));
     bookmark_app_helper_->Create(
         base::Bind(&extensions::ManagementGenerateAppForLinkFunction::
                        FinishCreateBookmarkApp,
diff --git a/chromium/chrome/browser/extensions/api/management/management_api_unittest.cc b/chromium/chrome/browser/extensions/api/management/management_api_unittest.cc
index 40f4701600e..15518413297 100644
--- a/chromium/chrome/browser/extensions/api/management/management_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/management/management_api_unittest.cc
@@ -37,12 +37,12 @@ namespace {
 
 std::unique_ptr<KeyedService> BuildManagementApi(
     content::BrowserContext* context) {
-  return base::MakeUnique<ManagementAPI>(context);
+  return std::make_unique<ManagementAPI>(context);
 }
 
 std::unique_ptr<KeyedService> BuildEventRouter(
     content::BrowserContext* profile) {
-  return base::MakeUnique<extensions::EventRouter>(
+  return std::make_unique<extensions::EventRouter>(
       profile, ExtensionPrefs::Get(profile));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc b/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc
index 4d28c195fff..2bf04ff08ba 100644
--- a/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc
+++ b/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc
@@ -173,7 +173,7 @@ void MDnsAPI::OnDnsSdEvent(const std::string& service_type,
   }
 
   std::unique_ptr<base::ListValue> results = mdns::OnServiceList::Create(args);
-  auto event = base::MakeUnique<Event>(events::MDNS_ON_SERVICE_LIST,
+  auto event = std::make_unique<Event>(events::MDNS_ON_SERVICE_LIST,
                                        mdns::OnServiceList::kEventName,
                                        std::move(results), browser_context_);
   event->filter_info.service_type = service_type;
diff --git a/chromium/chrome/browser/extensions/api/mdns/mdns_api_unittest.cc b/chromium/chrome/browser/extensions/api/mdns/mdns_api_unittest.cc
index 97fa36f65db..a74ce67ef9f 100644
--- a/chromium/chrome/browser/extensions/api/mdns/mdns_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/mdns/mdns_api_unittest.cc
@@ -10,12 +10,11 @@
 #include <utility>
 #include <vector>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/browser/extensions/test_extension_system.h"
-#include "chrome/browser/media/router/discovery/mdns/mock_dns_sd_registry.h"
+#include "chrome/browser/media/router/test/mock_dns_sd_registry.h"
 #include "chrome/common/extensions/api/mdns.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/mock_render_process_host.h"
@@ -74,17 +73,17 @@ class MockedMDnsAPI : public MDnsAPI {
 
 std::unique_ptr<KeyedService> MockedMDnsAPITestingFactoryFunction(
     content::BrowserContext* context) {
-  return base::MakeUnique<MockedMDnsAPI>(context);
+  return std::make_unique<MockedMDnsAPI>(context);
 }
 
 std::unique_ptr<KeyedService> MDnsAPITestingFactoryFunction(
     content::BrowserContext* context) {
-  return base::MakeUnique<MDnsAPI>(context);
+  return std::make_unique<MDnsAPI>(context);
 }
 
 std::unique_ptr<KeyedService> BuildEventRouter(
     content::BrowserContext* context) {
-  return base::MakeUnique<extensions::EventRouter>(
+  return std::make_unique<extensions::EventRouter>(
       context, ExtensionPrefs::Get(context));
 }
 
@@ -109,7 +108,7 @@ class MockEventRouter : public EventRouter {
 
 std::unique_ptr<KeyedService> MockEventRouterFactoryFunction(
     content::BrowserContext* context) {
-  return base::MakeUnique<MockEventRouter>(context,
+  return std::make_unique<MockEventRouter>(context,
                                            ExtensionPrefs::Get(context));
 }
 
@@ -187,7 +186,7 @@ class MDnsAPITest : public extensions::ExtensionServiceTestBase {
     ASSERT_TRUE(EventRouter::Get(browser_context()));  // constructs EventRouter
 
     registry_ =
-        base::MakeUnique<MockDnsSdRegistry>(MDnsAPI::Get(browser_context()));
+        std::make_unique<MockDnsSdRegistry>(MDnsAPI::Get(browser_context()));
     EXPECT_CALL(*dns_sd_registry(),
                 AddObserver(MDnsAPI::Get(browser_context())))
         .Times(1);
@@ -225,7 +224,7 @@ class MDnsAPITest : public extensions::ExtensionServiceTestBase {
       // Setting app.background.page = "background.html" is sufficient to make
       // the extension type TYPE_PLATFORM_APP.
       manifest.Set(extensions::manifest_keys::kPlatformAppBackgroundPage,
-                   base::MakeUnique<base::Value>("background.html"));
+                   std::make_unique<base::Value>("background.html"));
     }
 
     std::string error;
diff --git a/chromium/chrome/browser/extensions/api/mdns/mdns_apitest.cc b/chromium/chrome/browser/extensions/api/mdns/mdns_apitest.cc
index db83c5fd609..48bcf21aab1 100644
--- a/chromium/chrome/browser/extensions/api/mdns/mdns_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/mdns/mdns_apitest.cc
@@ -2,13 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/command_line.h"
-#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/mdns/mdns_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/media/router/discovery/mdns/mock_dns_sd_registry.h"
+#include "chrome/browser/media/router/test/mock_dns_sd_registry.h"
 #include "chrome/common/extensions/api/mdns.h"
 #include "extensions/common/switches.h"
 #include "extensions/test/result_catcher.h"
@@ -35,7 +36,7 @@ class MDnsAPITest : public ExtensionApiTest {
 
   void SetUpTestDnsSdRegistry() {
     extensions::MDnsAPI* api = extensions::MDnsAPI::Get(profile());
-    dns_sd_registry_ = base::MakeUnique<media_router::MockDnsSdRegistry>(api);
+    dns_sd_registry_ = std::make_unique<media_router::MockDnsSdRegistry>(api);
     EXPECT_CALL(*dns_sd_registry_, AddObserver(api))
         .Times(1);
     api->SetDnsSdRegistryForTesting(dns_sd_registry_.get());
diff --git a/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc b/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc
index 9ac0c2bf726..f672a2822b8 100644
--- a/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc
+++ b/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc
@@ -176,7 +176,7 @@ base::ListValue* ConstructFileSystemList(
     file_system_dict_value->SetKey(kNameKey, base::Value(filesystems[i].name));
     file_system_dict_value->SetKey(
         kGalleryIdKey,
-        base::Value(base::Uint64ToString(filesystems[i].pref_id)));
+        base::Value(base::NumberToString(filesystems[i].pref_id)));
     if (!filesystems[i].transient_device_id.empty()) {
       file_system_dict_value->SetKey(
           kDeviceIdKey, base::Value(filesystems[i].transient_device_id));
@@ -358,7 +358,7 @@ void MediaGalleriesEventRouter::OnGalleryChanged(
     const std::string& extension_id, MediaGalleryPrefId gallery_id) {
   MediaGalleries::GalleryChangeDetails details;
   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_CONTENTS_CHANGED;
-  details.gallery_id = base::Uint64ToString(gallery_id);
+  details.gallery_id = base::NumberToString(gallery_id);
   DispatchEventToExtension(extension_id,
                            events::MEDIA_GALLERIES_ON_GALLERY_CHANGED,
                            MediaGalleries::OnGalleryChanged::kEventName,
@@ -674,7 +674,7 @@ void MediaGalleriesGetMetadataFunction::GetMetadata(
       metadata_type == MediaGalleries::GET_METADATA_TYPE_ALL ||
       metadata_type == MediaGalleries::GET_METADATA_TYPE_NONE;
 
-  auto parser = base::MakeRefCounted<chrome::SafeMediaMetadataParser>(
+  auto parser = base::MakeRefCounted<SafeMediaMetadataParser>(
       GetProfile(), blob_uuid, total_blob_length, mime_type,
       get_attached_images);
   parser->Start(
@@ -709,7 +709,7 @@ void MediaGalleriesGetMetadataFunction::OnSafeMediaMetadataParserDone(
   }
 
   result_dictionary->Set(kAttachedImagesBlobInfoKey,
-                         base::MakeUnique<base::ListValue>());
+                         std::make_unique<base::ListValue>());
   metadata::AttachedImage* first_image = &attached_images->front();
   content::BrowserContext::CreateMemoryBackedBlob(
       GetProfile(), first_image->data.c_str(), first_image->data.size(), "",
@@ -844,7 +844,7 @@ void MediaGalleriesAddGalleryWatchFunction::HandleResponse(
   // onGalleryChanged event, that's an error.
   MediaGalleriesEventRouter* api = MediaGalleriesEventRouter::Get(GetProfile());
   api::media_galleries::AddGalleryWatchResult result;
-  result.gallery_id = base::Uint64ToString(gallery_id);
+  result.gallery_id = base::NumberToString(gallery_id);
 
   if (!api->ExtensionHasGalleryChangeListener(extension()->id())) {
     result.success = false;
diff --git a/chromium/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc b/chromium/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc
index dc857e6ffbd..46218419192 100644
--- a/chromium/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc
+++ b/chromium/chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc
@@ -40,8 +40,10 @@ MediaPerceptionAPIDelegateChromeOS::~MediaPerceptionAPIDelegateChromeOS() {}
 void MediaPerceptionAPIDelegateChromeOS::LoadCrOSComponent(
     const media_perception::ComponentType& type,
     LoadCrOSComponentCallback load_callback) {
-  component_updater::CrOSComponent::LoadComponent(
-      GetComponentNameForComponentType(type), std::move(load_callback));
+  g_browser_process->platform_part()->cros_component_manager()->Load(
+      GetComponentNameForComponentType(type),
+      component_updater::CrOSComponentManager::MountPolicy::kMount,
+      std::move(load_callback));
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/messaging/chrome_messaging_delegate.cc b/chromium/chrome/browser/extensions/api/messaging/chrome_messaging_delegate.cc
index d564de69c3d..eeaa8191412 100644
--- a/chromium/chrome/browser/extensions/api/messaging/chrome_messaging_delegate.cc
+++ b/chromium/chrome/browser/extensions/api/messaging/chrome_messaging_delegate.cc
@@ -4,9 +4,10 @@
 
 #include "chrome/browser/extensions/api/messaging/chrome_messaging_delegate.h"
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/messaging/incognito_connectability.h"
 #include "chrome/browser/extensions/api/messaging/native_message_port.h"
@@ -113,7 +114,7 @@ std::unique_ptr<MessagePort> ChromeMessagingDelegate::CreateReceiverForTab(
   if (!receiver_rfh)
     return nullptr;
 
-  return base::MakeUnique<ExtensionMessagePort>(
+  return std::make_unique<ExtensionMessagePort>(
       channel_delegate, receiver_port_id, extension_id, receiver_rfh,
       include_child_frames);
 }
@@ -133,7 +134,7 @@ ChromeMessagingDelegate::CreateReceiverForNativeApp(
       native_view, extension_id, native_app_name, allow_user_level, error_out);
   if (!native_host.get())
     return nullptr;
-  return base::MakeUnique<NativeMessagePort>(channel_delegate, receiver_port_id,
+  return std::make_unique<NativeMessagePort>(channel_delegate, receiver_port_id,
                                              std::move(native_host));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc
index 4fa51a6661c..325d811e3fb 100644
--- a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc
+++ b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc
@@ -8,18 +8,15 @@
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/grit/generated_resources.h"
-#include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/common/extension.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using infobars::InfoBar;
-using infobars::InfoBarManager;
-
 namespace extensions {
 
 namespace {
@@ -28,97 +25,6 @@ IncognitoConnectability::ScopedAlertTracker::Mode g_alert_mode =
     IncognitoConnectability::ScopedAlertTracker::INTERACTIVE;
 int g_alert_count = 0;
 
-class IncognitoConnectabilityInfoBarDelegate : public ConfirmInfoBarDelegate {
- public:
-  typedef base::Callback<void(
-      IncognitoConnectability::ScopedAlertTracker::Mode)> InfoBarCallback;
-
-  // Creates a confirmation infobar and delegate and adds the infobar to
-  // |infobar_service|.
-  static InfoBar* Create(InfoBarManager* infobar_manager,
-                         const base::string16& message,
-                         const InfoBarCallback& callback);
-
-  // Marks the infobar as answered so that the callback is not executed when the
-  // delegate is destroyed.
-  void set_answered() { answered_ = true; }
-
- private:
-  IncognitoConnectabilityInfoBarDelegate(const base::string16& message,
-                                         const InfoBarCallback& callback);
-  ~IncognitoConnectabilityInfoBarDelegate() override;
-
-  // ConfirmInfoBarDelegate:
-  Type GetInfoBarType() const override;
-  infobars::InfoBarDelegate::InfoBarIdentifier GetIdentifier() const override;
-  base::string16 GetMessageText() const override;
-  base::string16 GetButtonLabel(InfoBarButton button) const override;
-  bool Accept() override;
-  bool Cancel() override;
-
-  base::string16 message_;
-  bool answered_;
-  InfoBarCallback callback_;
-};
-
-// static
-InfoBar* IncognitoConnectabilityInfoBarDelegate::Create(
-    InfoBarManager* infobar_manager,
-    const base::string16& message,
-    const IncognitoConnectabilityInfoBarDelegate::InfoBarCallback& callback) {
-  return infobar_manager->AddInfoBar(infobar_manager->CreateConfirmInfoBar(
-      std::unique_ptr<ConfirmInfoBarDelegate>(
-          new IncognitoConnectabilityInfoBarDelegate(message, callback))));
-}
-
-IncognitoConnectabilityInfoBarDelegate::IncognitoConnectabilityInfoBarDelegate(
-    const base::string16& message,
-    const InfoBarCallback& callback)
-    : message_(message), answered_(false), callback_(callback) {
-}
-
-IncognitoConnectabilityInfoBarDelegate::
-    ~IncognitoConnectabilityInfoBarDelegate() {
-  if (!answered_) {
-    // The infobar has closed without the user expressing an explicit
-    // preference. The current request should be denied but further requests
-    // should show an interactive prompt.
-    callback_.Run(IncognitoConnectability::ScopedAlertTracker::INTERACTIVE);
-  }
-}
-
-infobars::InfoBarDelegate::Type
-IncognitoConnectabilityInfoBarDelegate::GetInfoBarType() const {
-  return PAGE_ACTION_TYPE;
-}
-
-infobars::InfoBarDelegate::InfoBarIdentifier
-IncognitoConnectabilityInfoBarDelegate::GetIdentifier() const {
-  return INCOGNITO_CONNECTABILITY_INFOBAR_DELEGATE;
-}
-
-base::string16 IncognitoConnectabilityInfoBarDelegate::GetMessageText() const {
-  return message_;
-}
-
-base::string16 IncognitoConnectabilityInfoBarDelegate::GetButtonLabel(
-    InfoBarButton button) const {
-  return l10n_util::GetStringUTF16(
-      (button == BUTTON_OK) ? IDS_PERMISSION_ALLOW : IDS_PERMISSION_DENY);
-}
-
-bool IncognitoConnectabilityInfoBarDelegate::Accept() {
-  callback_.Run(IncognitoConnectability::ScopedAlertTracker::ALWAYS_ALLOW);
-  answered_ = true;
-  return true;
-}
-
-bool IncognitoConnectabilityInfoBarDelegate::Cancel() {
-  callback_.Run(IncognitoConnectability::ScopedAlertTracker::ALWAYS_DENY);
-  answered_ = true;
-  return true;
-}
-
 }  // namespace
 
 IncognitoConnectability::ScopedAlertTracker::ScopedAlertTracker(Mode mode)
@@ -177,9 +83,9 @@ void IncognitoConnectability::Query(
 
   PendingOrigin& pending_origin =
       pending_origins_[make_pair(extension->id(), origin)];
-  InfoBarManager* infobar_manager =
+  InfoBarService* infobar_service =
       InfoBarService::FromWebContents(web_contents);
-  TabContext& tab_context = pending_origin[infobar_manager];
+  TabContext& tab_context = pending_origin[infobar_service];
   tab_context.callbacks.push_back(callback);
   if (tab_context.infobar) {
     // This tab is already displaying an infobar for this extension and origin.
@@ -197,19 +103,20 @@ void IncognitoConnectability::Query(
               ? IDS_EXTENSION_PROMPT_APP_CONNECT_FROM_INCOGNITO
               : IDS_EXTENSION_PROMPT_EXTENSION_CONNECT_FROM_INCOGNITO;
       tab_context.infobar = IncognitoConnectabilityInfoBarDelegate::Create(
-          infobar_manager, l10n_util::GetStringFUTF16(
-                               template_id, base::UTF8ToUTF16(origin.spec()),
-                               base::UTF8ToUTF16(extension->name())),
+          infobar_service,
+          l10n_util::GetStringFUTF16(template_id,
+                                     base::UTF8ToUTF16(origin.spec()),
+                                     base::UTF8ToUTF16(extension->name())),
           base::Bind(&IncognitoConnectability::OnInteractiveResponse,
                      weak_factory_.GetWeakPtr(), extension->id(), origin,
-                     infobar_manager));
+                     infobar_service));
       break;
     }
 
     // Testing code can override to always allow or deny.
     case ScopedAlertTracker::ALWAYS_ALLOW:
     case ScopedAlertTracker::ALWAYS_DENY:
-      OnInteractiveResponse(extension->id(), origin, infobar_manager,
+      OnInteractiveResponse(extension->id(), origin, infobar_service,
                             g_alert_mode);
       break;
   }
@@ -227,7 +134,7 @@ IncognitoConnectability::TabContext::~TabContext() {
 void IncognitoConnectability::OnInteractiveResponse(
     const std::string& extension_id,
     const GURL& origin,
-    InfoBarManager* infobar_manager,
+    InfoBarService* infobar_service,
     ScopedAlertTracker::Mode response) {
   switch (response) {
     case ScopedAlertTracker::ALWAYS_ALLOW:
@@ -245,29 +152,29 @@ void IncognitoConnectability::OnInteractiveResponse(
   DCHECK(base::ContainsKey(pending_origins_, make_pair(extension_id, origin)));
   PendingOrigin& pending_origin =
       pending_origins_[make_pair(extension_id, origin)];
-  DCHECK(base::ContainsKey(pending_origin, infobar_manager));
+  DCHECK(base::ContainsKey(pending_origin, infobar_service));
 
   std::vector<base::Callback<void(bool)>> callbacks;
   if (response == ScopedAlertTracker::INTERACTIVE) {
     // No definitive answer for this extension and origin. Execute only the
     // callbacks associated with this tab.
-    TabContext& tab_context = pending_origin[infobar_manager];
+    TabContext& tab_context = pending_origin[infobar_service];
     callbacks.swap(tab_context.callbacks);
-    pending_origin.erase(infobar_manager);
+    pending_origin.erase(infobar_service);
   } else {
     // We have a definitive answer for this extension and origin. Close all
     // other infobars and answer all the callbacks.
     for (const auto& map_entry : pending_origin) {
-      InfoBarManager* other_infobar_manager = map_entry.first;
+      InfoBarService* other_infobar_service = map_entry.first;
       const TabContext& other_tab_context = map_entry.second;
-      if (other_infobar_manager != infobar_manager) {
+      if (other_infobar_service != infobar_service) {
         // Disarm the delegate so that it doesn't think the infobar has been
         // dismissed.
         IncognitoConnectabilityInfoBarDelegate* delegate =
             static_cast<IncognitoConnectabilityInfoBarDelegate*>(
                 other_tab_context.infobar->delegate());
         delegate->set_answered();
-        other_infobar_manager->RemoveInfoBar(other_tab_context.infobar);
+        other_infobar_service->RemoveInfoBar(other_tab_context.infobar);
       }
       callbacks.insert(callbacks.end(), other_tab_context.callbacks.begin(),
                        other_tab_context.callbacks.end());
diff --git a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.h b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.h
index 9686db2b4f2..2984f8730cc 100644
--- a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.h
+++ b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.h
@@ -11,6 +11,8 @@
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "url/gurl.h"
 
+class InfoBarService;
+
 namespace content {
 class BrowserContext;
 class WebContents;
@@ -18,7 +20,6 @@ class WebContents;
 
 namespace infobars {
 class InfoBar;
-class InfoBarManager;
 }
 
 namespace extensions {
@@ -73,7 +74,7 @@ class IncognitoConnectability : public BrowserContextKeyedAPI {
     TabContext(const TabContext& other);
     ~TabContext();
 
-    // The infobar being shown in a given tab. The InfoBarManager maintains
+    // The infobar being shown in a given tab. The InfoBarService maintains
     // ownership of this object. This struct must always be destroyed before the
     // infobar it tracks.
     infobars::InfoBar* infobar;
@@ -88,7 +89,7 @@ class IncognitoConnectability : public BrowserContextKeyedAPI {
 
   typedef std::map<std::string, std::set<GURL> > ExtensionToOriginsMap;
   typedef std::pair<std::string, GURL> ExtensionOriginPair;
-  typedef std::map<infobars::InfoBarManager*, TabContext> PendingOrigin;
+  typedef std::map<InfoBarService*, TabContext> PendingOrigin;
   typedef std::map<ExtensionOriginPair, PendingOrigin> PendingOriginMap;
 
   // Called with the user's selection from the infobar.
@@ -96,7 +97,7 @@ class IncognitoConnectability : public BrowserContextKeyedAPI {
   // without selecting allow or deny.
   void OnInteractiveResponse(const std::string& extension_id,
                              const GURL& origin,
-                             infobars::InfoBarManager* infobar_manager,
+                             InfoBarService* infobar_service,
                              ScopedAlertTracker::Mode response);
 
   // Returns true if the (|extension|, |origin|) pair appears in the map.
diff --git a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.cc b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.cc
new file mode 100644
index 00000000000..17963d18b30
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.cc
@@ -0,0 +1,71 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.h"
+
+#include "chrome/browser/infobars/infobar_service.h"
+#include "chrome/grit/generated_resources.h"
+#include "components/infobars/core/infobar.h"
+#include "ui/base/l10n/l10n_util.h"
+
+namespace extensions {
+
+// static
+infobars::InfoBar* IncognitoConnectabilityInfoBarDelegate::Create(
+    InfoBarService* infobar_service,
+    const base::string16& message,
+    const IncognitoConnectabilityInfoBarDelegate::InfoBarCallback& callback) {
+  return infobar_service->AddInfoBar(infobar_service->CreateConfirmInfoBar(
+      std::unique_ptr<ConfirmInfoBarDelegate>(
+          new IncognitoConnectabilityInfoBarDelegate(message, callback))));
+}
+
+IncognitoConnectabilityInfoBarDelegate::IncognitoConnectabilityInfoBarDelegate(
+    const base::string16& message,
+    const InfoBarCallback& callback)
+    : message_(message), answered_(false), callback_(callback) {}
+
+IncognitoConnectabilityInfoBarDelegate::
+    ~IncognitoConnectabilityInfoBarDelegate() {
+  if (!answered_) {
+    // The infobar has closed without the user expressing an explicit
+    // preference. The current request should be denied but further requests
+    // should show an interactive prompt.
+    callback_.Run(IncognitoConnectability::ScopedAlertTracker::INTERACTIVE);
+  }
+}
+
+infobars::InfoBarDelegate::Type
+IncognitoConnectabilityInfoBarDelegate::GetInfoBarType() const {
+  return PAGE_ACTION_TYPE;
+}
+
+infobars::InfoBarDelegate::InfoBarIdentifier
+IncognitoConnectabilityInfoBarDelegate::GetIdentifier() const {
+  return INCOGNITO_CONNECTABILITY_INFOBAR_DELEGATE;
+}
+
+base::string16 IncognitoConnectabilityInfoBarDelegate::GetMessageText() const {
+  return message_;
+}
+
+base::string16 IncognitoConnectabilityInfoBarDelegate::GetButtonLabel(
+    InfoBarButton button) const {
+  return l10n_util::GetStringUTF16((button == BUTTON_OK) ? IDS_PERMISSION_ALLOW
+                                                         : IDS_PERMISSION_DENY);
+}
+
+bool IncognitoConnectabilityInfoBarDelegate::Accept() {
+  callback_.Run(IncognitoConnectability::ScopedAlertTracker::ALWAYS_ALLOW);
+  answered_ = true;
+  return true;
+}
+
+bool IncognitoConnectabilityInfoBarDelegate::Cancel() {
+  callback_.Run(IncognitoConnectability::ScopedAlertTracker::ALWAYS_DENY);
+  answered_ = true;
+  return true;
+}
+
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.h b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.h
new file mode 100644
index 00000000000..8b067019516
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability_infobar_delegate.h
@@ -0,0 +1,53 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_MESSAGING_INCOGNITO_CONNECTABILITY_INFOBAR_DELEGATE_H_
+#define CHROME_BROWSER_EXTENSIONS_API_MESSAGING_INCOGNITO_CONNECTABILITY_INFOBAR_DELEGATE_H_
+
+#include "base/callback_forward.h"
+#include "base/strings/string16.h"
+#include "chrome/browser/extensions/api/messaging/incognito_connectability.h"
+#include "components/infobars/core/confirm_infobar_delegate.h"
+
+class InfoBarService;
+
+namespace extensions {
+
+class IncognitoConnectabilityInfoBarDelegate : public ConfirmInfoBarDelegate {
+ public:
+  typedef base::Callback<void(
+      IncognitoConnectability::ScopedAlertTracker::Mode)>
+      InfoBarCallback;
+
+  // Creates a confirmation infobar and delegate and adds the infobar to
+  // |infobar_service|.
+  static infobars::InfoBar* Create(InfoBarService* infobar_service,
+                                   const base::string16& message,
+                                   const InfoBarCallback& callback);
+
+  // Marks the infobar as answered so that the callback is not executed when the
+  // delegate is destroyed.
+  void set_answered() { answered_ = true; }
+
+ private:
+  IncognitoConnectabilityInfoBarDelegate(const base::string16& message,
+                                         const InfoBarCallback& callback);
+  ~IncognitoConnectabilityInfoBarDelegate() override;
+
+  // ConfirmInfoBarDelegate:
+  Type GetInfoBarType() const override;
+  infobars::InfoBarDelegate::InfoBarIdentifier GetIdentifier() const override;
+  base::string16 GetMessageText() const override;
+  base::string16 GetButtonLabel(InfoBarButton button) const override;
+  bool Accept() override;
+  bool Cancel() override;
+
+  base::string16 message_;
+  bool answered_;
+  InfoBarCallback callback_;
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_MESSAGING_INCOGNITO_CONNECTABILITY_INFOBAR_DELEGATE_H_
diff --git a/chromium/chrome/browser/extensions/api/metrics_private/metrics_apitest.cc b/chromium/chrome/browser/extensions/api/metrics_private/metrics_apitest.cc
index c6fd082a92c..b41a3e14ee3 100644
--- a/chromium/chrome/browser/extensions/api/metrics_private/metrics_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/metrics_private/metrics_apitest.cc
@@ -94,8 +94,8 @@ void ValidateSparseHistogramSamples(
 
 void ValidateHistograms(const RecordedHistogram* recorded,
                         int count) {
-  base::StatisticsRecorder::Histograms histograms;
-  base::StatisticsRecorder::GetHistograms(&histograms);
+  const base::StatisticsRecorder::Histograms histograms =
+      base::StatisticsRecorder::GetHistograms();
 
   // Code other than the tests tun here will record some histogram values, but
   // we will ignore those. This function validates that all the histogram we
diff --git a/chromium/chrome/browser/extensions/api/module/module.cc b/chromium/chrome/browser/extensions/api/module/module.cc
index b3874b883c9..469c1a2f70c 100644
--- a/chromium/chrome/browser/extensions/api/module/module.cc
+++ b/chromium/chrome/browser/extensions/api/module/module.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/extensions/api/module/module.h"
 
+#include <memory>
 #include <string>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
@@ -48,19 +48,19 @@ ExtensionFunction::ResponseAction ExtensionSetUpdateUrlDataFunction::Run() {
 
   ExtensionPrefs::Get(browser_context())
       ->UpdateExtensionPref(extension_id(), extension::kUpdateURLData,
-                            base::MakeUnique<base::Value>(data));
+                            std::make_unique<base::Value>(data));
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction
 ExtensionIsAllowedIncognitoAccessFunction::Run() {
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(
+  return RespondNow(OneArgument(std::make_unique<base::Value>(
       util::IsIncognitoEnabled(extension_id(), browser_context()))));
 }
 
 ExtensionFunction::ResponseAction
 ExtensionIsAllowedFileSchemeAccessFunction::Run() {
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(
+  return RespondNow(OneArgument(std::make_unique<base::Value>(
       util::AllowFileAccess(extension_id(), browser_context()))));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/music_manager_private/music_manager_private_api.cc b/chromium/chrome/browser/extensions/api/music_manager_private/music_manager_private_api.cc
index 341e4cb6461..253b8944eac 100644
--- a/chromium/chrome/browser/extensions/api/music_manager_private/music_manager_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/music_manager_private/music_manager_private_api.cc
@@ -4,7 +4,8 @@
 
 #include "chrome/browser/extensions/api/music_manager_private/music_manager_private_api.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "chrome/browser/extensions/api/music_manager_private/device_id.h"
 
 using content::BrowserThread;
@@ -45,7 +46,7 @@ void MusicManagerPrivateGetDeviceIdFunction::DeviceIdCallback(
     SetError(kDeviceIdNotSupported);
     response = false;
   } else {
-    SetResult(base::MakeUnique<base::Value>(device_id));
+    SetResult(std::make_unique<base::Value>(device_id));
     response = true;
   }
 
diff --git a/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_api.cc b/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_api.cc
index 3fe62342f78..241bcff52ca 100644
--- a/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_api.cc
@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/common/extensions/api/networking_cast_private.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/networking_private/networking_cast_private_delegate.h"
@@ -47,7 +46,7 @@ cast_api::TDLSStatus ParseTDLSStatus(const std::string& status) {
 
 std::unique_ptr<NetworkingCastPrivateDelegate::Credentials> AsCastCredentials(
     api::networking_cast_private::VerificationProperties& properties) {
-  return base::MakeUnique<NetworkingCastPrivateDelegate::Credentials>(
+  return std::make_unique<NetworkingCastPrivateDelegate::Credentials>(
       properties.certificate,
       properties.intermediate_certificates
           ? *properties.intermediate_certificates
diff --git a/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_apitest.cc b/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_apitest.cc
index 7eed80d9c61..b2f52e01681 100644
--- a/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/networking_cast_private/networking_cast_private_apitest.cc
@@ -10,7 +10,6 @@
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
@@ -139,7 +138,7 @@ class NetworkingCastPrivateApiTest : public ExtensionApiTest {
  private:
   std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
   CreateNetworkingCastPrivateDelegate() {
-    return base::MakeUnique<TestNetworkingCastPrivateDelegate>();
+    return std::make_unique<TestNetworkingCastPrivateDelegate>();
   }
 
   ChromeNetworkingCastPrivateDelegate::FactoryCallback
diff --git a/chromium/chrome/browser/extensions/api/networking_config_chromeos_apitest_chromeos.cc b/chromium/chrome/browser/extensions/api/networking_config_chromeos_apitest_chromeos.cc
index 56cd505bf57..e9994eab59b 100644
--- a/chromium/chrome/browser/extensions/api/networking_config_chromeos_apitest_chromeos.cc
+++ b/chromium/chrome/browser/extensions/api/networking_config_chromeos_apitest_chromeos.cc
@@ -13,7 +13,9 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_impl.h"
 #include "chrome/browser/chromeos/net/network_portal_notification_controller.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/notifications/notification_display_service_tester.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
@@ -23,8 +25,8 @@
 #include "extensions/test/result_catcher.h"
 #include "net/base/net_errors.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
-#include "ui/message_center/message_center.h"
-#include "ui/message_center/message_center_observer.h"
+#include "ui/message_center/notification.h"
+#include "ui/message_center/notification_delegate.h"
 
 using chromeos::DBusThreadManager;
 using chromeos::NetworkPortalDetector;
@@ -33,8 +35,6 @@ using chromeos::NetworkPortalNotificationController;
 using chromeos::ShillDeviceClient;
 using chromeos::ShillProfileClient;
 using chromeos::ShillServiceClient;
-using message_center::MessageCenter;
-using message_center::MessageCenterObserver;
 
 namespace {
 
@@ -42,36 +42,6 @@ const char kWifiDevicePath[] = "/device/stub_wifi_device1";
 const char kWifi1ServicePath[] = "stub_wifi1";
 const char kWifi1ServiceGUID[] = "wifi1_guid";
 
-class TestNotificationObserver : public MessageCenterObserver {
- public:
-  TestNotificationObserver() {
-    MessageCenter::Get()->AddObserver(this);
-  }
-
-  ~TestNotificationObserver() override {
-    MessageCenter::Get()->RemoveObserver(this);
-  }
-
-  void WaitForNotificationToDisplay() {
-    run_loop_.Run();
-  }
-
-  void OnNotificationDisplayed(
-      const std::string& notification_id,
-      const message_center::DisplaySource source) override {
-    if (notification_id ==
-        NetworkPortalNotificationController::kNotificationId) {
-      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                    run_loop_.QuitClosure());
-    }
-  }
-
- private:
-  base::RunLoop run_loop_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestNotificationObserver);
-};
-
 }  // namespace
 
 class NetworkingConfigTest
@@ -82,6 +52,9 @@ class NetworkingConfigTest
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
 
+    display_service_ = std::make_unique<NotificationDisplayServiceTester>(
+        chromeos::ProfileHelper::GetSigninProfile());
+
     DBusThreadManager* const dbus_manager = DBusThreadManager::Get();
     ShillServiceClient::TestInterface* const service_test =
         dbus_manager->GetShillServiceClient()->GetTestInterface();
@@ -145,10 +118,10 @@ class NetworkingConfigTest
         .status;
   }
 
+ protected:
   NetworkPortalDetectorImpl* network_portal_detector_ = nullptr;
-
- private:
   const extensions::Extension* extension_ = nullptr;
+  std::unique_ptr<NotificationDisplayServiceTester> display_service_;
 };
 
 IN_PROC_BROWSER_TEST_F(NetworkingConfigTest, ApiAvailability) {
@@ -169,19 +142,16 @@ IN_PROC_BROWSER_TEST_F(NetworkingConfigTest, FullTest) {
   // This will cause the extension to register for wifi1.
   ASSERT_TRUE(RunExtensionTest("full_test.html")) << message_;
 
-  TestNotificationObserver observer;
-
   SimulateCaptivePortal();
 
   // Wait until a captive portal notification is displayed and verify that it is
   // the expected captive portal notification.
-  observer.WaitForNotificationToDisplay();
-  EXPECT_TRUE(MessageCenter::Get()->FindVisibleNotificationById(
-      NetworkPortalNotificationController::kNotificationId));
+  auto notification = display_service_->GetNotification(
+      NetworkPortalNotificationController::kNotificationId);
+  ASSERT_TRUE(notification);
 
   // Simulate the user click which leads to the extension being notified.
-  MessageCenter::Get()->ClickOnNotificationButton(
-      NetworkPortalNotificationController::kNotificationId,
+  notification->delegate()->ButtonClick(
       NetworkPortalNotificationController::kUseExtensionButtonIndex);
 
   extensions::ResultCatcher catcher;
diff --git a/chromium/chrome/browser/extensions/api/networking_private/networking_private_apitest.cc b/chromium/chrome/browser/extensions/api/networking_private/networking_private_apitest.cc
index 642d7a17eea..8fd35c34579 100644
--- a/chromium/chrome/browser/extensions/api/networking_private/networking_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/networking_private/networking_private_apitest.cc
@@ -14,7 +14,6 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.h"
 #include "chrome/browser/extensions/extension_apitest.h"
@@ -197,11 +196,11 @@ class TestNetworkingPrivateDelegate : public NetworkingPrivateDelegate {
   }
 
   std::unique_ptr<base::DictionaryValue> GetGlobalPolicy() override {
-    return base::MakeUnique<base::DictionaryValue>();
+    return std::make_unique<base::DictionaryValue>();
   }
 
   std::unique_ptr<base::DictionaryValue> GetCertificateLists() override {
-    return base::MakeUnique<base::DictionaryValue>();
+    return std::make_unique<base::DictionaryValue>();
   }
 
   bool EnableNetworkType(const std::string& type) override {
@@ -395,14 +394,14 @@ class NetworkingPrivateApiTest : public ExtensionApiTest {
  private:
   std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
   CreateTestNetworkingCastPrivateDelegate(bool test_failure) {
-    return base::MakeUnique<TestNetworkingCastPrivateDelegate>(test_failure);
+    return std::make_unique<TestNetworkingCastPrivateDelegate>(test_failure);
   }
 
   std::unique_ptr<KeyedService> CreateTestNetworkingPrivateDelegate(
       bool test_failure) {
     CHECK(!networking_private_delegate_);
     auto delegate =
-        base::MakeUnique<TestNetworkingPrivateDelegate>(test_failure);
+        std::make_unique<TestNetworkingPrivateDelegate>(test_failure);
     networking_private_delegate_ = delegate.get();
     return delegate;
   }
diff --git a/chromium/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc b/chromium/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
index 7a0c2a93298..4abe0b8919d 100644
--- a/chromium/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc
@@ -155,10 +155,6 @@ class UIDelegateStub : public NetworkingPrivateDelegate::UIDelegate {
   void ShowAccountDetails(const std::string& guid) const override {
     ++s_show_account_details_called_;
   }
-  bool HandleConnectFailed(const std::string& guid,
-                           const std::string error) const override {
-    return false;
-  }
 };
 
 // static
@@ -281,7 +277,7 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
     device_test_->SetDeviceProperty(kCellularDevicePath, shill::kMinProperty,
                                     base::Value("test_min"));
     device_test_->SetDeviceProperty(kCellularDevicePath,
-                                    shill::kModelIDProperty,
+                                    shill::kModelIdProperty,
                                     base::Value("test_model_id"));
     device_test_->SetSimLocked(kCellularDevicePath, false);
 
@@ -490,7 +486,7 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
 
   std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
   CreateNetworkingCastPrivateDelegate() {
-    return base::MakeUnique<TestNetworkingCastPrivateDelegate>();
+    return std::make_unique<TestNetworkingCastPrivateDelegate>();
   }
 
   bool SetupCertificates() {
diff --git a/chromium/chrome/browser/extensions/api/networking_private/networking_private_service_client_apitest.cc b/chromium/chrome/browser/extensions/api/networking_private/networking_private_service_client_apitest.cc
index a50e5718866..6b2b32bdea8 100644
--- a/chromium/chrome/browser/extensions/api/networking_private/networking_private_service_client_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/networking_private/networking_private_service_client_apitest.cc
@@ -9,7 +9,6 @@
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
@@ -148,7 +147,7 @@ class NetworkingPrivateServiceClientApiTest : public ExtensionApiTest {
  private:
   std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
   CreateNetworkingCastPrivateDelegate() {
-    return base::MakeUnique<TestNetworkingCastPrivateDelegate>();
+    return std::make_unique<TestNetworkingCastPrivateDelegate>();
   }
 
   ChromeNetworkingCastPrivateDelegate::FactoryCallback
diff --git a/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.cc b/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.cc
index fbdbf5de19f..ea3f6167c4c 100644
--- a/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.cc
+++ b/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.cc
@@ -20,11 +20,5 @@ void NetworkingPrivateUIDelegateChromeOS::ShowAccountDetails(
   chromeos::NetworkConnect::Get()->ShowMobileSetup(guid);
 }
 
-bool NetworkingPrivateUIDelegateChromeOS::HandleConnectFailed(
-    const std::string& guid,
-    const std::string error) const {
-  return chromeos::NetworkConnect::Get()->MaybeShowConfigureUI(guid, error);
-}
-
 }  // namespace extensions
 }  // namespace chromeos
diff --git a/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.h b/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.h
index 43732c0a4d6..941fd241ed4 100644
--- a/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.h
+++ b/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.h
@@ -20,8 +20,6 @@ class NetworkingPrivateUIDelegateChromeOS
 
   // NetworkingPrivateDelegate::UIDelegate
   void ShowAccountDetails(const std::string& guid) const override;
-  bool HandleConnectFailed(const std::string& guid,
-                           const std::string error) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateUIDelegateChromeOS);
diff --git a/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_factory_impl.cc b/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_factory_impl.cc
index 9d4b6c56017..f4ec25dd253 100644
--- a/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_factory_impl.cc
+++ b/chromium/chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_factory_impl.cc
@@ -4,7 +4,8 @@
 
 #include "chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_factory_impl.h"
 
-#include "base/memory/ptr_util.h"
+#include <memory>
+
 #include "build/build_config.h"
 
 #if defined(OS_CHROMEOS)
@@ -22,7 +23,7 @@ NetworkingPrivateUIDelegateFactoryImpl::
 std::unique_ptr<NetworkingPrivateDelegate::UIDelegate>
 NetworkingPrivateUIDelegateFactoryImpl::CreateDelegate() {
 #if defined(OS_CHROMEOS)
-  return base::MakeUnique<
+  return std::make_unique<
       chromeos::extensions::NetworkingPrivateUIDelegateChromeOS>();
 #else
   return nullptr;
diff --git a/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc b/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc
index 44b44fed40a..fb63bc5e496 100644
--- a/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc
@@ -6,12 +6,12 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/guid.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
@@ -27,7 +27,6 @@
 #include "chrome/browser/notifications/notification_handler.h"
 #include "chrome/browser/notifications/notifier_state_tracker.h"
 #include "chrome/browser/notifications/notifier_state_tracker_factory.h"
-#include "chrome/browser/notifications/web_notification_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/notifications/notification_style.h"
 #include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
@@ -376,10 +375,7 @@ bool NotificationsApiFunction::CreateNotification(
       base::UTF8ToUTF16(extension_->name()), extension_->url(),
       message_center::NotifierId(message_center::NotifierId::APPLICATION,
                                  extension_->id()),
-      optional_fields,
-      new WebNotificationDelegate(NotificationHandler::Type::EXTENSION,
-                                  GetProfile(), notification_id,
-                                  extension_->url()));
+      optional_fields, nullptr /* delegate */);
 
   // Apply the "requireInteraction" flag. The value defaults to false.
   notification.set_never_timeout(options->require_interaction &&
@@ -606,7 +602,7 @@ bool NotificationsCreateFunction::RunNotificationsApi() {
       notification_id = base::RandBytesAsString(16);
   }
 
-  SetResult(base::MakeUnique<base::Value>(notification_id));
+  SetResult(std::make_unique<base::Value>(notification_id));
 
   // TODO(crbug.com/749402): Cap the length of notification Ids to a certain
   // limit if the histogram indicates that this is safe to do.
@@ -639,7 +635,7 @@ bool NotificationsUpdateFunction::RunNotificationsApi() {
           CreateScopedIdentifier(extension_->id(), params_->notification_id));
 
   if (!matched_notification) {
-    SetResult(base::MakeUnique<base::Value>(false));
+    SetResult(std::make_unique<base::Value>(false));
     SendResponse(true);
     return true;
   }
@@ -653,7 +649,7 @@ bool NotificationsUpdateFunction::RunNotificationsApi() {
   // TODO(dewittj): Add more human-readable error strings if this fails.
   bool could_update_notification = UpdateNotification(
       params_->notification_id, &params_->options, &notification);
-  SetResult(base::MakeUnique<base::Value>(could_update_notification));
+  SetResult(std::make_unique<base::Value>(could_update_notification));
   if (!could_update_notification)
     return false;
 
@@ -676,7 +672,7 @@ bool NotificationsClearFunction::RunNotificationsApi() {
   bool cancel_result = GetDisplayHelper()->Close(
       CreateScopedIdentifier(extension_->id(), params_->notification_id));
 
-  SetResult(base::MakeUnique<base::Value>(cancel_result));
+  SetResult(std::make_unique<base::Value>(cancel_result));
   SendResponse(true);
 
   return true;
@@ -721,7 +717,7 @@ bool NotificationsGetPermissionLevelFunction::RunNotificationsApi() {
           : api::notifications::PERMISSION_LEVEL_DENIED;
 
   SetResult(
-      base::MakeUnique<base::Value>(api::notifications::ToString(result)));
+      std::make_unique<base::Value>(api::notifications::ToString(result)));
   SendResponse(true);
 
   return true;
diff --git a/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc b/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc
index a9ac81512dd..6b34b68c345 100644
--- a/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/containers/circular_deque.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -175,7 +177,7 @@ class NotificationsApiTest : public ExtensionApiTest {
 
     DCHECK(profile());
     display_service_tester_ =
-        base::MakeUnique<NotificationDisplayServiceTester>(profile());
+        std::make_unique<NotificationDisplayServiceTester>(profile());
   }
 
   void TearDownOnMainThread() override {
@@ -384,11 +386,23 @@ IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestUserGesture) {
 
   {
     UserGestureCatcher catcher;
-    notification->ButtonClick(0);
+
+    // Action button event.
+    display_service_tester_->SimulateClick(
+        NotificationHandler::Type::EXTENSION, notification->id(),
+        0 /* action_index */, base::nullopt /* reply */);
     EXPECT_TRUE(catcher.GetNextResult());
-    notification->Click();
+
+    // Click event.
+    display_service_tester_->SimulateClick(
+        NotificationHandler::Type::EXTENSION, notification->id(),
+        base::nullopt /* action_index */, base::nullopt /* reply */);
     EXPECT_TRUE(catcher.GetNextResult());
-    notification->Close(true /* by_user */);
+
+    // Close event.
+    display_service_tester_->RemoveNotification(
+        NotificationHandler::Type::EXTENSION, notification->id(),
+        true /* by_user */, false /* silent */);
     EXPECT_TRUE(catcher.GetNextResult());
 
     // Note that |notification| no longer points to valid memory.
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.cc b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.cc
index e787a2f1f96..30280a6a7d5 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.cc
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.cc
@@ -246,7 +246,7 @@ void PasswordsPrivateDelegateImpl::ExportPasswords(
   // exiting this method. TODO(crbug.com/495290): Pass the native window
   // directly to the reauth-handling code.
   web_contents_ = web_contents;
-  if (!password_access_authenticator_.EnsureUserIsAuthenticated()) {
+  if (!password_access_authenticator_.ForceUserReauthentication()) {
     return;
   }
 
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl_unittest.cc b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl_unittest.cc
index 257c90bc810..18816b55a21 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl_unittest.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/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ -181,7 +180,7 @@ TEST_F(PasswordsPrivateDelegateImplTest, GetSavedPasswordsList) {
   EXPECT_EQ(0u, tracker.call_count());
 
   PasswordFormList list;
-  list.push_back(base::MakeUnique<autofill::PasswordForm>());
+  list.push_back(std::make_unique<autofill::PasswordForm>());
   delegate.SetPasswordList(list);
   EXPECT_EQ(1u, tracker.call_count());
 
@@ -198,7 +197,7 @@ TEST_F(PasswordsPrivateDelegateImplTest, GetPasswordExceptionsList) {
   EXPECT_EQ(0u, tracker.call_count());
 
   PasswordFormList list;
-  list.push_back(base::MakeUnique<autofill::PasswordForm>());
+  list.push_back(std::make_unique<autofill::PasswordForm>());
   delegate.SetPasswordExceptionList(list);
   EXPECT_EQ(1u, tracker.call_count());
 
@@ -269,6 +268,11 @@ TEST_F(PasswordsPrivateDelegateImplTest, TestReauthOnExport) {
   delegate.ExportPasswords(nullptr);
   EXPECT_TRUE(reauth_called);
 
+  // Export should ignore previous reauthentication results.
+  reauth_called = false;
+  delegate.ExportPasswords(nullptr);
+  EXPECT_TRUE(reauth_called);
+
   // TODO(crbug.com/341477): Once the export flow has defined messages to UI,
   // such as progress indication, intercept them with PasswordEventObserver and
   // check that exporting is aborted if the authentication failed.
diff --git a/chromium/chrome/browser/extensions/api/permissions/permissions_api.cc b/chromium/chrome/browser/extensions/api/permissions/permissions_api.cc
index 3b52c7334c2..d78cf8f3d83 100644
--- a/chromium/chrome/browser/extensions/api/permissions/permissions_api.cc
+++ b/chromium/chrome/browser/extensions/api/permissions/permissions_api.cc
@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/permissions/permissions_api_helpers.h"
 #include "chrome/browser/extensions/extension_management.h"
@@ -234,8 +233,9 @@ bool PermissionsRequestFunction::RunAsync() {
     install_ui_.reset(new ExtensionInstallPrompt(GetAssociatedWebContents()));
     install_ui_->ShowDialog(
         base::Bind(&PermissionsRequestFunction::OnInstallPromptDone, this),
-        extension(), nullptr, base::MakeUnique<ExtensionInstallPrompt::Prompt>(
-                                  ExtensionInstallPrompt::PERMISSIONS_PROMPT),
+        extension(), nullptr,
+        std::make_unique<ExtensionInstallPrompt::Prompt>(
+            ExtensionInstallPrompt::PERMISSIONS_PROMPT),
         requested_permissions_->Clone(),
         ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   }
diff --git a/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc b/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc
index 7632c69265f..d50b84f903a 100644
--- a/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers.cc
@@ -8,7 +8,6 @@
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/api/permissions.h"
 #include "extensions/common/error_utils.h"
@@ -146,7 +145,7 @@ std::unique_ptr<const PermissionSet> UnpackPermissionSet(
     }
   }
 
-  return base::MakeUnique<PermissionSet>(apis, manifest_permissions, origins,
+  return std::make_unique<PermissionSet>(apis, manifest_permissions, origins,
                                          URLPatternSet());
 }
 
diff --git a/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers_unittest.cc b/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers_unittest.cc
index b99b3efc0c3..a1705a98a30 100644
--- a/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/permissions/permissions_api_helpers_unittest.cc
@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/api/permissions.h"
 #include "extensions/common/permissions/permission_set.h"
@@ -142,14 +141,14 @@ TEST(ExtensionPermissionsAPIHelpers, Unpack) {
   {
     Permissions permissions_object;
     value->Clear();
-    value->Set("origins", base::MakeUnique<base::Value>(2));
+    value->Set("origins", std::make_unique<base::Value>(2));
     EXPECT_FALSE(Permissions::Populate(*value, &permissions_object));
   }
 
   {
     Permissions permissions_object;
     value->Clear();
-    value->Set("permissions", base::MakeUnique<base::Value>(2));
+    value->Set("permissions", std::make_unique<base::Value>(2));
     EXPECT_FALSE(Permissions::Populate(*value, &permissions_object));
   }
 
@@ -158,7 +157,7 @@ TEST(ExtensionPermissionsAPIHelpers, Unpack) {
     Permissions permissions_object;
     value->Clear();
     value->Set("origins", origins->CreateDeepCopy());
-    value->Set("random", base::MakeUnique<base::Value>(3));
+    value->Set("random", std::make_unique<base::Value>(3));
     EXPECT_TRUE(Permissions::Populate(*value, &permissions_object));
     permissions = UnpackPermissionSet(permissions_object, true, &error);
     EXPECT_TRUE(permissions.get());
diff --git a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.cc b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.cc
index 7fd7ef4dced..3cfa9e91a8b 100644
--- a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.cc
+++ b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.cc
@@ -21,6 +21,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_errors.h"
 #include "net/cert/x509_certificate.h"
+#include "net/cert/x509_util.h"
 
 namespace extensions {
 
@@ -273,9 +274,8 @@ void PlatformKeysInternalSelectClientCertificatesFunction::
     }
 
     api_pk::Match result_match;
-    std::string der_encoded_cert;
-    net::X509Certificate::GetDEREncoded(match->os_cert_handle(),
-                                        &der_encoded_cert);
+    base::StringPiece der_encoded_cert =
+        net::x509_util::CryptoBufferAsStringPiece(match->cert_buffer());
     result_match.certificate.assign(der_encoded_cert.begin(),
                                     der_encoded_cert.end());
 
diff --git a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.h b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.h
index 233e264a032..9cb73cf9fcd 100644
--- a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.h
+++ b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_api.h
@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 
-#include "chrome/browser/extensions/chrome_extension_function.h"
+#include "extensions/browser/extension_function.h"
 
 namespace net {
 class X509Certificate;
@@ -33,7 +33,7 @@ std::string PlatformKeysTokenIdToApiId(
 }  // namespace platform_keys
 
 class PlatformKeysInternalSelectClientCertificatesFunction
-    : public ChromeUIThreadExtensionFunction {
+    : public UIThreadExtensionFunction {
  private:
   ~PlatformKeysInternalSelectClientCertificatesFunction() override;
   ResponseAction Run() override;
@@ -48,7 +48,7 @@ class PlatformKeysInternalSelectClientCertificatesFunction
 };
 
 class PlatformKeysInternalGetPublicKeyFunction
-    : public ChromeUIThreadExtensionFunction {
+    : public UIThreadExtensionFunction {
  private:
   ~PlatformKeysInternalGetPublicKeyFunction() override;
   ResponseAction Run() override;
@@ -57,8 +57,7 @@ class PlatformKeysInternalGetPublicKeyFunction
                              PLATFORMKEYSINTERNAL_GETPUBLICKEY);
 };
 
-class PlatformKeysInternalSignFunction
-    : public ChromeUIThreadExtensionFunction {
+class PlatformKeysInternalSignFunction : public UIThreadExtensionFunction {
  private:
   ~PlatformKeysInternalSignFunction() override;
   ResponseAction Run() override;
diff --git a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_apitest_nss.cc b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_apitest_nss.cc
index 73d502cf1bb..63971e9f50f 100644
--- a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_apitest_nss.cc
+++ b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_apitest_nss.cc
@@ -9,29 +9,18 @@
 
 #include "base/json/json_writer.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service.h"
 #include "chrome/browser/chromeos/platform_keys/platform_keys_service_factory.h"
-#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
-#include "chrome/browser/chromeos/policy/user_policy_test_helper.h"
-#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/api/platform_keys/platform_keys_test_base.h"
 #include "chrome/browser/net/nss_context.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chromeos/chromeos_switches.h"
 #include "components/policy/policy_constants.h"
-#include "components/signin/core/account_id/account_id.h"
-#include "components/user_manager/user_names.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/test/test_utils.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_test_system_nss_key_slot.h"
-#include "extensions/browser/extension_registry.h"
-#include "extensions/browser/notification_types.h"
-#include "net/base/net_errors.h"
 #include "net/cert/nss_cert_database.h"
 #include "net/cert/test_root_certs.h"
 #include "net/test/cert_test_util.h"
@@ -39,98 +28,63 @@
 
 namespace {
 
-enum DeviceStatus { DEVICE_STATUS_ENROLLED, DEVICE_STATUS_NOT_ENROLLED };
-
-enum UserStatus {
-  USER_STATUS_MANAGED_AFFILIATED_DOMAIN,
-  USER_STATUS_MANAGED_OTHER_DOMAIN,
-  USER_STATUS_UNMANAGED
-};
-
-class PlatformKeysTest : public ExtensionApiTest {
+class PlatformKeysTest : public PlatformKeysTestBase {
  public:
-  PlatformKeysTest(DeviceStatus device_status,
+  PlatformKeysTest(EnrollmentStatus enrollment_status,
                    UserStatus user_status,
                    bool key_permission_policy)
-      : device_status_(device_status),
-        user_status_(user_status),
-        key_permission_policy_(key_permission_policy) {
-    if (user_status_ != USER_STATUS_UNMANAGED)
-      SetupInitialEmptyPolicy();
-  }
-
-  void SetUpCommandLine(base::CommandLine* command_line) override {
-    ExtensionApiTest::SetUpCommandLine(command_line);
-
-    if (policy_helper_)
-      policy_helper_->UpdateCommandLine(command_line);
-
-    command_line->AppendSwitchASCII(
-        chromeos::switches::kLoginUser,
-        user_manager::StubAccountId().GetUserEmail());
-  }
-
-  void SetUpInProcessBrowserTestFixture() override {
-    ExtensionApiTest::SetUpInProcessBrowserTestFixture();
-
-    if (device_status_ == DEVICE_STATUS_ENROLLED) {
-      device_policy_test_helper_.device_policy()->policy_data().set_username(
-          user_status_ == USER_STATUS_MANAGED_AFFILIATED_DOMAIN
-              ? user_manager::StubAccountId().GetUserEmail()
-              : "someuser@anydomain.com");
-
-      device_policy_test_helper_.device_policy()->Build();
-      device_policy_test_helper_.MarkAsEnterpriseOwned();
-    }
-  }
+      : PlatformKeysTestBase(SystemTokenStatus::EXISTS,
+                             enrollment_status,
+                             user_status),
+        key_permission_policy_(key_permission_policy) {}
 
   void SetUpOnMainThread() override {
-    if (policy_helper_)
-      policy_helper_->WaitForInitialPolicy(browser()->profile());
-
-    {
-      base::RunLoop loop;
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO, FROM_HERE,
-          base::BindOnce(&PlatformKeysTest::SetUpTestSystemSlotOnIO,
-                         base::Unretained(this),
-                         browser()->profile()->GetResourceContext(),
-                         loop.QuitClosure()));
-      loop.Run();
-    }
+    PlatformKeysTestBase::SetUpOnMainThread();
 
-    ExtensionApiTest::SetUpOnMainThread();
+    if (IsPreTest())
+      return;
 
     {
       base::RunLoop loop;
       GetNSSCertDatabaseForProfile(
-          browser()->profile(),
-          base::Bind(&PlatformKeysTest::SetupTestCerts, base::Unretained(this),
-                     loop.QuitClosure()));
+          profile(),
+          base::BindRepeating(&PlatformKeysTest::SetupTestCerts,
+                              base::Unretained(this), loop.QuitClosure()));
       loop.Run();
     }
 
     base::FilePath extension_path = test_data_dir_.AppendASCII("platform_keys");
     extension_ = LoadExtension(extension_path);
 
-    if (policy_helper_ && key_permission_policy_)
-      SetupKeyPermissionPolicy();
+    if (user_status() != UserStatus::UNMANAGED && key_permission_policy_)
+      SetupKeyPermissionUserPolicy();
   }
 
-  void TearDownOnMainThread() override {
-    ExtensionApiTest::TearDownOnMainThread();
+  void SetupKeyPermissionUserPolicy() {
+    policy::PolicyMap policy;
 
-    base::RunLoop loop;
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
-        base::BindOnce(&PlatformKeysTest::TearDownTestSystemSlotOnIO,
-                       base::Unretained(this), loop.QuitClosure()));
-    loop.Run();
+    // Set up the test policy that gives |extension_| the permission to access
+    // corporate keys.
+    std::unique_ptr<base::DictionaryValue> key_permissions_policy =
+        std::make_unique<base::DictionaryValue>();
+    {
+      std::unique_ptr<base::DictionaryValue> cert1_key_permission(
+          new base::DictionaryValue);
+      cert1_key_permission->SetKey("allowCorporateKeyUsage", base::Value(true));
+      key_permissions_policy->SetWithoutPathExpansion(
+          extension_->id(), std::move(cert1_key_permission));
+    }
+
+    policy.Set(policy::key::kKeyPermissions, policy::POLICY_LEVEL_MANDATORY,
+               policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
+               std::move(key_permissions_policy), nullptr);
+
+    mock_policy_provider()->UpdateChromePolicy(policy);
   }
 
   chromeos::PlatformKeysService* GetPlatformKeysService() {
     return chromeos::PlatformKeysServiceFactory::GetForBrowserContext(
-        browser()->profile());
+        profile());
   }
 
   bool RunExtensionTest(const std::string& test_suite_name) {
@@ -139,15 +93,16 @@ class PlatformKeysTest : public ExtensionApiTest {
 
     // Only if the current user is of the same domain as the device is enrolled
     // to, the system token is available to the extension.
-    if (device_status_ == DEVICE_STATUS_ENROLLED &&
-        user_status_ == USER_STATUS_MANAGED_AFFILIATED_DOMAIN) {
+    if (system_token_status() == SystemTokenStatus::EXISTS &&
+        enrollment_status() == EnrollmentStatus::ENROLLED &&
+        user_status() == UserStatus::MANAGED_AFFILIATED_DOMAIN) {
       system_token_availability = "systemTokenEnabled";
     }
 
     GURL url = extension_->GetResourceURL(base::StringPrintf(
         "basic.html?%s#%s", system_token_availability.c_str(),
         test_suite_name.c_str()));
-    return RunExtensionSubtest("", url.spec());
+    return TestExtension(url.spec());
   }
 
   void RegisterClient1AsCorporateKey() {
@@ -173,55 +128,19 @@ class PlatformKeysTest : public ExtensionApiTest {
   }
 
  protected:
-  const DeviceStatus device_status_;
-  const UserStatus user_status_;
-
   scoped_refptr<net::X509Certificate> client_cert1_;
   scoped_refptr<net::X509Certificate> client_cert2_;
   const extensions::Extension* extension_;
 
  private:
-  void SetupInitialEmptyPolicy() {
-    policy_helper_.reset(new policy::UserPolicyTestHelper(
-        user_manager::StubAccountId().GetUserEmail()));
-    policy_helper_->Init(
-        base::DictionaryValue() /* empty mandatory policy */,
-        base::DictionaryValue() /* empty recommended policy */);
-  }
-
-  void SetupKeyPermissionPolicy() {
-    // Set up the test policy that gives |extension_| the permission to access
-    // corporate keys.
-    base::DictionaryValue key_permissions_policy;
-    {
-      std::unique_ptr<base::DictionaryValue> cert1_key_permission(
-          new base::DictionaryValue);
-      cert1_key_permission->SetKey("allowCorporateKeyUsage", base::Value(true));
-      key_permissions_policy.SetWithoutPathExpansion(
-          extension_->id(), std::move(cert1_key_permission));
-    }
-
-    std::string key_permissions_policy_str;
-    base::JSONWriter::WriteWithOptions(key_permissions_policy,
-                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
-                                       &key_permissions_policy_str);
-
-    base::DictionaryValue user_policy;
-    user_policy.SetKey(policy::key::kKeyPermissions,
-                       base::Value(key_permissions_policy_str));
-
-    policy_helper_->UpdatePolicy(
-        user_policy, base::DictionaryValue() /* empty recommended policy */,
-        browser()->profile());
-  }
-
   void GotPermissionsForExtension(
       const base::Closure& done_callback,
       std::unique_ptr<chromeos::KeyPermissions::PermissionsForExtension>
           permissions_for_ext) {
     std::string client_cert1_spki =
         chromeos::platform_keys::GetSubjectPublicKeyInfo(client_cert1_);
-    permissions_for_ext->RegisterKeyForCorporateUsage(client_cert1_spki);
+    permissions_for_ext->RegisterKeyForCorporateUsage(
+        client_cert1_spki, {chromeos::KeyPermissions::KeyLocation::kUserSlot});
     done_callback.Run();
   }
 
@@ -242,7 +161,7 @@ class PlatformKeysTest : public ExtensionApiTest {
     // system wide key slot.
     client_cert2_ = net::ImportClientCertAndKeyFromFile(
         net::GetTestCertsDirectory(), "client_2.pem", "client_2.pk8",
-        test_system_slot_->slot());
+        test_system_slot()->slot());
     ASSERT_TRUE(client_cert2_.get());
   }
 
@@ -255,28 +174,9 @@ class PlatformKeysTest : public ExtensionApiTest {
         test_data_dir_.AppendASCII("platform_keys").AppendASCII("root.pem"));
   }
 
-  void SetUpTestSystemSlotOnIO(content::ResourceContext* context,
-                               const base::Closure& done_callback) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    test_system_slot_.reset(new crypto::ScopedTestSystemNSSKeySlot());
-    ASSERT_TRUE(test_system_slot_->ConstructedSuccessfully());
-
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                     done_callback);
-  }
-
-  void TearDownTestSystemSlotOnIO(const base::Closure& done_callback) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    test_system_slot_.reset();
-
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                     done_callback);
-  }
-
   const bool key_permission_policy_;
-  std::unique_ptr<policy::UserPolicyTestHelper> policy_helper_;
-  policy::DevicePolicyCrosTestHelper device_policy_test_helper_;
-  std::unique_ptr<crypto::ScopedTestSystemNSSKeySlot> test_system_slot_;
+
+  DISALLOW_COPY_AND_ASSIGN(PlatformKeysTest);
 };
 
 class TestSelectDelegate
@@ -319,22 +219,23 @@ class TestSelectDelegate
   net::CertificateList certs_to_select_;
 };
 
-class UnmanagedPlatformKeysTest
-    : public PlatformKeysTest,
-      public ::testing::WithParamInterface<DeviceStatus> {
+class UnmanagedPlatformKeysTest : public PlatformKeysTest,
+                                  public ::testing::WithParamInterface<
+                                      PlatformKeysTestBase::EnrollmentStatus> {
  public:
   UnmanagedPlatformKeysTest()
       : PlatformKeysTest(GetParam(),
-                         USER_STATUS_UNMANAGED,
+                         UserStatus::UNMANAGED,
                          false /* unused */) {}
 };
 
 struct Params {
-  Params(DeviceStatus device_status, UserStatus user_status)
-      : device_status_(device_status), user_status_(user_status) {}
+  Params(PlatformKeysTestBase::EnrollmentStatus enrollment_status,
+         PlatformKeysTestBase::UserStatus user_status)
+      : enrollment_status_(enrollment_status), user_status_(user_status) {}
 
-  DeviceStatus device_status_;
-  UserStatus user_status_;
+  PlatformKeysTestBase::EnrollmentStatus enrollment_status_;
+  PlatformKeysTestBase::UserStatus user_status_;
 };
 
 class ManagedWithPermissionPlatformKeysTest
@@ -342,7 +243,7 @@ class ManagedWithPermissionPlatformKeysTest
       public ::testing::WithParamInterface<Params> {
  public:
   ManagedWithPermissionPlatformKeysTest()
-      : PlatformKeysTest(GetParam().device_status_,
+      : PlatformKeysTest(GetParam().enrollment_status_,
                          GetParam().user_status_,
                          true /* grant the extension key permission */) {}
 };
@@ -352,13 +253,17 @@ class ManagedWithoutPermissionPlatformKeysTest
       public ::testing::WithParamInterface<Params> {
  public:
   ManagedWithoutPermissionPlatformKeysTest()
-      : PlatformKeysTest(GetParam().device_status_,
+      : PlatformKeysTest(GetParam().enrollment_status_,
                          GetParam().user_status_,
                          false /* do not grant key permission */) {}
 };
 
 }  // namespace
 
+IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, PRE_Basic) {
+  RunPreTest();
+}
+
 // At first interactively selects |client_cert1_| and |client_cert2_| to grant
 // permissions and afterwards runs more basic tests.
 // After the initial two interactive calls, the simulated user does not select
@@ -370,11 +275,15 @@ IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, Basic) {
   certs.push_back(client_cert1_);
 
   GetPlatformKeysService()->SetSelectDelegate(
-      base::WrapUnique(new TestSelectDelegate(certs)));
+      std::make_unique<TestSelectDelegate>(certs));
 
   ASSERT_TRUE(RunExtensionTest("basicTests")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, PRE_Permissions) {
+  RunPreTest();
+}
+
 // On interactive calls, the simulated user always selects |client_cert1_| if
 // matching.
 IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, Permissions) {
@@ -382,26 +291,37 @@ IN_PROC_BROWSER_TEST_P(UnmanagedPlatformKeysTest, Permissions) {
   certs.push_back(client_cert1_);
 
   GetPlatformKeysService()->SetSelectDelegate(
-      base::WrapUnique(new TestSelectDelegate(certs)));
+      std::make_unique<TestSelectDelegate>(certs));
 
   ASSERT_TRUE(RunExtensionTest("permissionTests")) << message_;
 }
 
-INSTANTIATE_TEST_CASE_P(Unmanaged,
-                        UnmanagedPlatformKeysTest,
-                        ::testing::Values(DEVICE_STATUS_ENROLLED,
-                                          DEVICE_STATUS_NOT_ENROLLED));
+INSTANTIATE_TEST_CASE_P(
+    Unmanaged,
+    UnmanagedPlatformKeysTest,
+    ::testing::Values(PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+                      PlatformKeysTestBase::EnrollmentStatus::NOT_ENROLLED));
+
+IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
+                       PRE_UserPermissionsBlocked) {
+  RunPreTest();
+}
 
 IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
                        UserPermissionsBlocked) {
   // To verify that the user is not prompted for any certificate selection,
   // set up a delegate that fails on any invocation.
   GetPlatformKeysService()->SetSelectDelegate(
-      base::MakeUnique<TestSelectDelegate>(net::CertificateList()));
+      std::make_unique<TestSelectDelegate>(net::CertificateList()));
 
   ASSERT_TRUE(RunExtensionTest("managedProfile")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
+                       PRE_CorporateKeyAccessBlocked) {
+  RunPreTest();
+}
+
 // A corporate key must not be useable if there is no policy permitting it.
 IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
                        CorporateKeyAccessBlocked) {
@@ -410,7 +330,7 @@ IN_PROC_BROWSER_TEST_P(ManagedWithoutPermissionPlatformKeysTest,
   // To verify that the user is not prompted for any certificate selection,
   // set up a delegate that fails on any invocation.
   GetPlatformKeysService()->SetSelectDelegate(
-      base::WrapUnique(new TestSelectDelegate(net::CertificateList())));
+      std::make_unique<TestSelectDelegate>(net::CertificateList()));
 
   ASSERT_TRUE(RunExtensionTest("corporateKeyWithoutPermissionTests"))
       << message_;
@@ -420,9 +340,17 @@ INSTANTIATE_TEST_CASE_P(
     ManagedWithoutPermission,
     ManagedWithoutPermissionPlatformKeysTest,
     ::testing::Values(
-        Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_AFFILIATED_DOMAIN),
-        Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN),
-        Params(DEVICE_STATUS_NOT_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN)));
+        Params(PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_AFFILIATED_DOMAIN),
+        Params(PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_OTHER_DOMAIN),
+        Params(PlatformKeysTestBase::EnrollmentStatus::NOT_ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_OTHER_DOMAIN)));
+
+IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
+                       PRE_PolicyGrantsAccessToCorporateKey) {
+  RunPreTest();
+}
 
 IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
                        PolicyGrantsAccessToCorporateKey) {
@@ -434,18 +362,31 @@ IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
   certs.push_back(client_cert1_);
 
   GetPlatformKeysService()->SetSelectDelegate(
-      base::MakeUnique<TestSelectDelegate>(certs));
+      std::make_unique<TestSelectDelegate>(certs));
 
   ASSERT_TRUE(RunExtensionTest("corporateKeyWithPermissionTests")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
+                       PRE_PolicyDoesGrantAccessToNonCorporateKey) {
+  RunPreTest();
+}
+
+IN_PROC_BROWSER_TEST_P(ManagedWithPermissionPlatformKeysTest,
                        PolicyDoesGrantAccessToNonCorporateKey) {
-  // The policy grants access to corporate keys but none are available.
+  // The policy grants access to corporate keys.
   // As the profile is managed, the user must not be able to grant any
-  // certificate permission. Set up a delegate that fails on any invocation.
+  // certificate permission.
+  // If the user is not affilited, no corporate keys are available. Set up a
+  // delegate that fails on any invocation. If the user is affiliated, client_2
+  // on the system token will be avialable for selection, as it is implicitly
+  // corporate.
+  net::CertificateList certs;
+  if (user_status() == UserStatus::MANAGED_AFFILIATED_DOMAIN)
+    certs.push_back(nullptr);
+
   GetPlatformKeysService()->SetSelectDelegate(
-      base::MakeUnique<TestSelectDelegate>(net::CertificateList()));
+      std::make_unique<TestSelectDelegate>(certs));
 
   ASSERT_TRUE(RunExtensionTest("policyDoesGrantAccessToNonCorporateKey"))
       << message_;
@@ -455,6 +396,9 @@ INSTANTIATE_TEST_CASE_P(
     ManagedWithPermission,
     ManagedWithPermissionPlatformKeysTest,
     ::testing::Values(
-        Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_AFFILIATED_DOMAIN),
-        Params(DEVICE_STATUS_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN),
-        Params(DEVICE_STATUS_NOT_ENROLLED, USER_STATUS_MANAGED_OTHER_DOMAIN)));
+        Params(PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_AFFILIATED_DOMAIN),
+        Params(PlatformKeysTestBase::EnrollmentStatus::ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_OTHER_DOMAIN),
+        Params(PlatformKeysTestBase::EnrollmentStatus::NOT_ENROLLED,
+               PlatformKeysTestBase::UserStatus::MANAGED_OTHER_DOMAIN)));
diff --git a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_test_base.cc b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_test_base.cc
new file mode 100644
index 00000000000..0c25f117ab1
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_test_base.cc
@@ -0,0 +1,223 @@
+// 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/extensions/api/platform_keys/platform_keys_test_base.h"
+
+#include "base/path_service.h"
+#include "base/run_loop.h"
+#include "chrome/browser/chromeos/policy/affiliation_test_helper.h"
+#include "chrome/browser/policy/profile_policy_connector.h"
+#include "chrome/browser/policy/profile_policy_connector_factory.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/fake_session_manager_client.h"
+#include "chromeos/dbus/session_manager_client.h"
+#include "components/policy/core/browser/browser_policy_connector.h"
+#include "components/policy/policy_constants.h"
+#include "content/public/test/test_launcher.h"
+#include "crypto/scoped_test_system_nss_key_slot.h"
+#include "extensions/test/result_catcher.h"
+#include "google_apis/gaia/gaia_constants.h"
+#include "google_apis/gaia/gaia_switches.h"
+#include "google_apis/gaia/gaia_urls.h"
+#include "net/dns/mock_host_resolver.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/test/embedded_test_server/http_request.h"
+#include "net/test/embedded_test_server/http_response.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+const char kAffiliationID[] = "some-affiliation-id";
+const char kTestUserinfoToken[] = "fake-userinfo-token";
+
+using policy::affiliation_test_helper::kEnterpriseUserEmail;
+using policy::affiliation_test_helper::kEnterpriseUserGaiaId;
+
+PlatformKeysTestBase::PlatformKeysTestBase(
+    SystemTokenStatus system_token_status,
+    EnrollmentStatus enrollment_status,
+    UserStatus user_status)
+    : system_token_status_(system_token_status),
+      enrollment_status_(enrollment_status),
+      user_status_(user_status),
+      account_id_(AccountId::FromUserEmailGaiaId(kEnterpriseUserEmail,
+                                                 kEnterpriseUserGaiaId)) {
+  // Command line should not be tweaked as if user is already logged in.
+  set_chromeos_user_ = false;
+  // We log in without running browser.
+  set_exit_when_last_browser_closes(false);
+}
+
+PlatformKeysTestBase::~PlatformKeysTestBase() {}
+
+void PlatformKeysTestBase::SetUp() {
+  base::FilePath test_data_dir;
+  PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
+  embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
+
+  embedded_test_server()->RegisterRequestHandler(base::BindRepeating(
+      &FakeGaia::HandleRequest, base::Unretained(&fake_gaia_)));
+
+  // Don't spin up the IO thread yet since no threads are allowed while
+  // spawning sandbox host process. See crbug.com/322732.
+  ASSERT_TRUE(embedded_test_server()->InitializeAndListen());
+
+  // Start https wrapper here so that the URLs can be pointed at it in
+  // SetUpCommandLine().
+  ASSERT_TRUE(gaia_https_forwarder_.Initialize(
+      GaiaUrls::GetInstance()->gaia_url().host(),
+      embedded_test_server()->base_url()));
+
+  ExtensionApiTest::SetUp();
+}
+
+void PlatformKeysTestBase::SetUpCommandLine(base::CommandLine* command_line) {
+  ExtensionApiTest::SetUpCommandLine(command_line);
+
+  policy::affiliation_test_helper::AppendCommandLineSwitchesForLoginManager(
+      command_line);
+
+  const GURL gaia_url = gaia_https_forwarder_.GetURLForSSLHost(std::string());
+  command_line->AppendSwitchASCII(::switches::kGaiaUrl, gaia_url.spec());
+  command_line->AppendSwitchASCII(::switches::kLsoUrl, gaia_url.spec());
+  command_line->AppendSwitchASCII(::switches::kGoogleApisUrl, gaia_url.spec());
+
+  fake_gaia_.Initialize();
+  fake_gaia_.set_issue_oauth_code_cookie(true);
+}
+
+void PlatformKeysTestBase::SetUpInProcessBrowserTestFixture() {
+  ExtensionApiTest::SetUpInProcessBrowserTestFixture();
+
+  chromeos::FakeSessionManagerClient* fake_session_manager_client =
+      new chromeos::FakeSessionManagerClient;
+  chromeos::DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
+      std::unique_ptr<chromeos::SessionManagerClient>(
+          fake_session_manager_client));
+
+  if (enrollment_status() == EnrollmentStatus::ENROLLED) {
+    std::set<std::string> device_affiliation_ids;
+    device_affiliation_ids.insert(kAffiliationID);
+    policy::affiliation_test_helper::SetDeviceAffiliationID(
+        &device_policy_test_helper_, fake_session_manager_client,
+        device_affiliation_ids);
+  }
+
+  if (user_status() == UserStatus::MANAGED_AFFILIATED_DOMAIN) {
+    std::set<std::string> user_affiliation_ids;
+    user_affiliation_ids.insert(kAffiliationID);
+    policy::UserPolicyBuilder user_policy;
+    policy::affiliation_test_helper::SetUserAffiliationIDs(
+        &user_policy, fake_session_manager_client, account_id_.GetUserEmail(),
+        user_affiliation_ids);
+  }
+
+  EXPECT_CALL(mock_policy_provider_, IsInitializationComplete(testing::_))
+      .WillRepeatedly(testing::Return(true));
+  mock_policy_provider_.SetAutoRefresh();
+  policy::BrowserPolicyConnector::SetPolicyProviderForTesting(
+      &mock_policy_provider_);
+}
+
+void PlatformKeysTestBase::SetUpOnMainThread() {
+  host_resolver()->AddRule("*", "127.0.0.1");
+  // Start the accept thread as the sandbox host process has already been
+  // spawned.
+  embedded_test_server()->StartAcceptingConnections();
+
+  FakeGaia::AccessTokenInfo token_info;
+  token_info.scopes.insert(GaiaConstants::kDeviceManagementServiceOAuth);
+  token_info.scopes.insert(GaiaConstants::kOAuthWrapBridgeUserInfoScope);
+  token_info.audience = GaiaUrls::GetInstance()->oauth2_chrome_client_id();
+  token_info.token = kTestUserinfoToken;
+  token_info.email = account_id_.GetUserEmail();
+  fake_gaia_.IssueOAuthToken(policy::affiliation_test_helper::kFakeRefreshToken,
+                             token_info);
+
+  // On PRE_ test stage list of users is empty at this point. Then in the body
+  // of PRE_ test kEnterpriseUser is added. Afterwards in the main test flow
+  // after PRE_ test the list of user contains one kEnterpriseUser user.
+  // This user logs in.
+  if (!IsPreTest()) {
+    policy::affiliation_test_helper::LoginUser(account_id_);
+
+    if (user_status() != UserStatus::UNMANAGED) {
+      policy::ProfilePolicyConnector* const connector =
+          policy::ProfilePolicyConnectorFactory::GetForBrowserContext(
+              profile());
+      connector->OverrideIsManagedForTesting(true);
+    }
+  }
+
+  if (system_token_status() == SystemTokenStatus::EXISTS) {
+    base::RunLoop loop;
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&PlatformKeysTestBase::SetUpTestSystemSlotOnIO,
+                       base::Unretained(this), loop.QuitClosure()));
+    loop.Run();
+  }
+
+  ExtensionApiTest::SetUpOnMainThread();
+}
+
+void PlatformKeysTestBase::TearDownOnMainThread() {
+  ExtensionApiTest::TearDownOnMainThread();
+
+  if (system_token_status() == SystemTokenStatus::EXISTS) {
+    base::RunLoop loop;
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&PlatformKeysTestBase::TearDownTestSystemSlotOnIO,
+                       base::Unretained(this), loop.QuitClosure()));
+    loop.Run();
+  }
+  EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete());
+}
+
+void PlatformKeysTestBase::PrepareTestSystemSlotOnIO(
+    crypto::ScopedTestSystemNSSKeySlot* system_slot) {}
+
+void PlatformKeysTestBase::RunPreTest() {
+  policy::affiliation_test_helper::PreLoginUser(account_id_);
+}
+
+bool PlatformKeysTestBase::TestExtension(const std::string& page_url) {
+  DCHECK(!page_url.empty()) << "page_url cannot be empty";
+  Browser* const browser = CreateBrowser(profile());
+
+  extensions::ResultCatcher catcher;
+  ui_test_utils::NavigateToURL(browser, GURL(page_url));
+
+  if (!catcher.GetNextResult()) {
+    message_ = catcher.message();
+    return false;
+  }
+  return true;
+}
+
+bool PlatformKeysTestBase::IsPreTest() {
+  return content::IsPreTest();
+}
+
+void PlatformKeysTestBase::SetUpTestSystemSlotOnIO(
+    base::OnceClosure done_callback) {
+  test_system_slot_ = std::make_unique<crypto::ScopedTestSystemNSSKeySlot>();
+  ASSERT_TRUE(test_system_slot_->ConstructedSuccessfully());
+
+  PrepareTestSystemSlotOnIO(test_system_slot_.get());
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                   std::move(done_callback));
+}
+
+void PlatformKeysTestBase::TearDownTestSystemSlotOnIO(
+    base::OnceClosure done_callback) {
+  test_system_slot_.reset();
+
+  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+                                   std::move(done_callback));
+}
diff --git a/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_test_base.h b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_test_base.h
new file mode 100644
index 00000000000..01f5ff06467
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/platform_keys/platform_keys_test_base.h
@@ -0,0 +1,106 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_PLATFORM_KEYS_PLATFORM_KEYS_TEST_BASE_H_
+#define CHROME_BROWSER_EXTENSIONS_API_PLATFORM_KEYS_PLATFORM_KEYS_TEST_BASE_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "chrome/browser/chromeos/login/test/https_forwarder.h"
+#include "chrome/browser/chromeos/policy/device_policy_cros_browser_test.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "components/policy/core/common/mock_configuration_policy_provider.h"
+#include "components/signin/core/account_id/account_id.h"
+#include "google_apis/gaia/fake_gaia.h"
+
+namespace crypto {
+class ScopedTestSystemNSSKeySlot;
+}
+
+// An ExtensionApiTest which provides additional setup for system token
+// availability, device enrollment status, user affiliation and user policy.
+// Every test case is supposed to have a PRE_ test case which must call
+// PlatformKeysTestBase::RunPreTest.
+class PlatformKeysTestBase : public ExtensionApiTest {
+ public:
+  enum class SystemTokenStatus { EXISTS, DOES_NOT_EXIST };
+
+  enum class EnrollmentStatus { ENROLLED, NOT_ENROLLED };
+
+  enum class UserStatus {
+    UNMANAGED,
+    MANAGED_AFFILIATED_DOMAIN,
+    MANAGED_OTHER_DOMAIN
+  };
+
+  PlatformKeysTestBase(SystemTokenStatus system_token_status,
+                       EnrollmentStatus enrollment_status,
+                       UserStatus user_status);
+  ~PlatformKeysTestBase() override;
+
+ protected:
+  // ExtensionApiTest:
+  void SetUp() override;
+  void SetUpCommandLine(base::CommandLine* command_line) override;
+  void SetUpInProcessBrowserTestFixture() override;
+  void SetUpOnMainThread() override;
+  void TearDownOnMainThread() override;
+
+  // Will be called with the system slot on the IO thread, if a system slot is
+  // being created.  The subclass can override this to perform its own
+  // preparations with the system slot.
+  virtual void PrepareTestSystemSlotOnIO(
+      crypto::ScopedTestSystemNSSKeySlot* system_slot);
+
+  SystemTokenStatus system_token_status() { return system_token_status_; }
+  EnrollmentStatus enrollment_status() { return enrollment_status_; }
+  UserStatus user_status() { return user_status_; }
+
+  policy::MockConfigurationPolicyProvider* mock_policy_provider() {
+    return &mock_policy_provider_;
+  }
+
+  crypto::ScopedTestSystemNSSKeySlot* test_system_slot() {
+    return test_system_slot_.get();
+  }
+
+  // This must be called from the PRE_ test cases.
+  void RunPreTest();
+
+  // Load |page_url| in a new browser in the current profile and wait for PASSED
+  // or FAILED notification. The functionality of this function is reduced
+  // functionality of RunExtensionSubtest(), but we don't use it here because it
+  // requires function InProcessBrowserTest::browser() to return non-NULL
+  // pointer. Unfortunately it returns the value which is set in constructor and
+  // can't be modified. Because on login flow there is no browser, the function
+  // InProcessBrowserTest::browser() always returns NULL. Besides this we need
+  // only very little functionality from RunExtensionSubtest(). Thus so that
+  // don't make RunExtensionSubtest() too complex we just introduce a new
+  // function.
+  bool TestExtension(const std::string& page_url);
+
+  // Returns true if called from a PRE_ test.
+  bool IsPreTest();
+
+ private:
+  void SetUpTestSystemSlotOnIO(base::OnceClosure done_callback);
+  void TearDownTestSystemSlotOnIO(base::OnceClosure done_callback);
+
+  const SystemTokenStatus system_token_status_;
+  const EnrollmentStatus enrollment_status_;
+  const UserStatus user_status_;
+
+  const AccountId account_id_;
+
+  policy::DevicePolicyCrosTestHelper device_policy_test_helper_;
+  std::unique_ptr<crypto::ScopedTestSystemNSSKeySlot> test_system_slot_;
+  policy::MockConfigurationPolicyProvider mock_policy_provider_;
+  FakeGaia fake_gaia_;
+  chromeos::HTTPSForwarder gaia_https_forwarder_;
+
+  DISALLOW_COPY_AND_ASSIGN(PlatformKeysTestBase);
+};
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_PLATFORM_KEYS_PLATFORM_KEYS_TEST_BASE_H_
diff --git a/chromium/chrome/browser/extensions/api/preference/preference_api.cc b/chromium/chrome/browser/extensions/api/preference/preference_api.cc
index 153c8f78eda..e6ce843eacd 100644
--- a/chromium/chrome/browser/extensions/api/preference/preference_api.cc
+++ b/chromium/chrome/browser/extensions/api/preference/preference_api.cc
@@ -12,7 +12,6 @@
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ -113,6 +112,8 @@ const PrefMappingEntry kPrefMapping[] = {
      APIPermission::kProxy},
     {"referrersEnabled", prefs::kEnableReferrers, APIPermission::kPrivacy,
      APIPermission::kPrivacy},
+    {"doNotTrackEnabled", prefs::kEnableDoNotTrack, APIPermission::kPrivacy,
+     APIPermission::kPrivacy},
     {"safeBrowsingEnabled", prefs::kSafeBrowsingEnabled,
      APIPermission::kPrivacy, APIPermission::kPrivacy},
     {"safeBrowsingExtendedReportingEnabled",
@@ -205,7 +206,7 @@ class InvertBooleanTransformer : public PrefTransformerInterface {
     bool bool_value = false;
     bool result = value->GetAsBoolean(&bool_value);
     DCHECK(result);
-    return base::MakeUnique<base::Value>(!bool_value);
+    return std::make_unique<base::Value>(!bool_value);
   }
 };
 
@@ -219,10 +220,10 @@ class NetworkPredictionTransformer : public PrefTransformerInterface {
     const bool pref_found = extension_pref->GetAsBoolean(&bool_value);
     DCHECK(pref_found) << "Preference not found.";
     if (bool_value) {
-      return base::MakeUnique<base::Value>(
+      return std::make_unique<base::Value>(
           chrome_browser_net::NETWORK_PREDICTION_DEFAULT);
     }
-    return base::MakeUnique<base::Value>(
+    return std::make_unique<base::Value>(
         chrome_browser_net::NETWORK_PREDICTION_NEVER);
   }
 
@@ -231,7 +232,7 @@ class NetworkPredictionTransformer : public PrefTransformerInterface {
     int int_value = chrome_browser_net::NETWORK_PREDICTION_DEFAULT;
     const bool pref_found = browser_pref->GetAsInteger(&int_value);
     DCHECK(pref_found) << "Preference not found.";
-    return base::MakeUnique<base::Value>(
+    return std::make_unique<base::Value>(
         int_value != chrome_browser_net::NETWORK_PREDICTION_NEVER);
   }
 };
@@ -292,11 +293,11 @@ class PrefMapping {
     DCHECK_EQ(arraysize(kPrefMapping), mapping_.size());
     DCHECK_EQ(arraysize(kPrefMapping), event_mapping_.size());
     RegisterPrefTransformer(proxy_config::prefs::kProxy,
-                            base::MakeUnique<ProxyPrefTransformer>());
+                            std::make_unique<ProxyPrefTransformer>());
     RegisterPrefTransformer(prefs::kBlockThirdPartyCookies,
-                            base::MakeUnique<InvertBooleanTransformer>());
+                            std::make_unique<InvertBooleanTransformer>());
     RegisterPrefTransformer(prefs::kNetworkPredictionOptions,
-                            base::MakeUnique<NetworkPredictionTransformer>());
+                            std::make_unique<NetworkPredictionTransformer>());
   }
 
   ~PrefMapping() {
diff --git a/chromium/chrome/browser/extensions/api/preference/preference_helpers.cc b/chromium/chrome/browser/extensions/api/preference/preference_helpers.cc
index 15b5d34a241..3414501b336 100644
--- a/chromium/chrome/browser/extensions/api/preference/preference_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/preference/preference_helpers.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/extensions/api/preference/preference_helpers.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/json/json_writer.h"
@@ -127,7 +128,7 @@ void DispatchEventToExtensions(Profile* profile,
 
       std::unique_ptr<base::ListValue> args_copy(args->DeepCopy());
       auto event =
-          base::MakeUnique<Event>(histogram_value, event_name,
+          std::make_unique<Event>(histogram_value, event_name,
                                   std::move(args_copy), restrict_to_profile);
       router->DispatchEventToExtension(extension->id(), std::move(event));
     }
diff --git a/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc b/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc
index c7639303ea4..780aafeeb1e 100644
--- a/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc
@@ -18,7 +18,6 @@
 #include <utility>
 
 #include "base/base64.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -367,7 +366,7 @@ std::unique_ptr<base::DictionaryValue> CreateProxyRulesDict(
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_FIXED_SERVERS);
 
-  auto extension_proxy_rules = base::MakeUnique<base::DictionaryValue>();
+  auto extension_proxy_rules = std::make_unique<base::DictionaryValue>();
 
   std::string proxy_servers;
   if (!proxy_config.GetProxyServer(&proxy_servers)) {
@@ -434,7 +433,7 @@ std::unique_ptr<base::DictionaryValue> CreateProxyRulesDict(
 
 std::unique_ptr<base::DictionaryValue> CreateProxyServerDict(
     const net::ProxyServer& proxy) {
-  auto out = base::MakeUnique<base::DictionaryValue>();
+  auto out = std::make_unique<base::DictionaryValue>();
   switch (proxy.scheme()) {
     case net::ProxyServer::SCHEME_HTTP:
       out->SetString(keys::kProxyConfigRuleScheme, "http");
@@ -466,7 +465,7 @@ std::unique_ptr<base::DictionaryValue> CreatePacScriptDict(
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_PAC_SCRIPT);
 
-  auto pac_script_dict = base::MakeUnique<base::DictionaryValue>();
+  auto pac_script_dict = std::make_unique<base::DictionaryValue>();
   std::string pac_url;
   if (!proxy_config.GetPacUrl(&pac_url)) {
     LOG(ERROR) << "Invalid proxy configuration. Missing PAC URL.";
@@ -496,7 +495,7 @@ std::unique_ptr<base::DictionaryValue> CreatePacScriptDict(
 std::unique_ptr<base::ListValue> TokenizeToStringList(
     const std::string& in,
     const std::string& delims) {
-  auto out = base::MakeUnique<base::ListValue>();
+  auto out = std::make_unique<base::ListValue>();
   base::StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->AppendString(entries.token());
diff --git a/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers_unittest.cc b/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers_unittest.cc
index be4c9da390c..85ff80162b4 100644
--- a/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/proxy/proxy_api_helpers_unittest.cc
@@ -9,7 +9,6 @@
 #include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api_constants.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
@@ -33,7 +32,7 @@ const char kSamplePacScriptUrl[] = "http://wpad/wpad.dat";
 // extension API.
 std::unique_ptr<base::DictionaryValue> CreateTestProxyServerDict(
     const std::string& host) {
-  auto dict = base::MakeUnique<base::DictionaryValue>();
+  auto dict = std::make_unique<base::DictionaryValue>();
   dict->SetString(keys::kProxyConfigRuleHost, host);
   return dict;
 }
@@ -44,7 +43,7 @@ std::unique_ptr<base::DictionaryValue> CreateTestProxyServerDict(
     const std::string& schema,
     const std::string& host,
     int port) {
-  auto dict = base::MakeUnique<base::DictionaryValue>();
+  auto dict = std::make_unique<base::DictionaryValue>();
   dict->SetString(keys::kProxyConfigRuleScheme, schema);
   dict->SetString(keys::kProxyConfigRuleHost, host);
   dict->SetInteger(keys::kProxyConfigRulePort, port);
@@ -119,7 +118,7 @@ TEST(ExtensionProxyApiHelpers, GetPacUrlFromExtensionPref) {
   EXPECT_FALSE(bad_message);
 
   // Set up a pac script.
-  auto pacScriptDict = base::MakeUnique<base::DictionaryValue>();
+  auto pacScriptDict = std::make_unique<base::DictionaryValue>();
   pacScriptDict->SetString(keys::kProxyConfigPacScriptUrl, kSamplePacScriptUrl);
   proxy_config.Set(keys::kProxyConfigPacScript, std::move(pacScriptDict));
 
@@ -148,7 +147,7 @@ TEST(ExtensionProxyApiHelpers, GetPacDataFromExtensionPref) {
   EXPECT_FALSE(bad_message);
 
   // Set up a PAC script.
-  auto pacScriptDict = base::MakeUnique<base::DictionaryValue>();
+  auto pacScriptDict = std::make_unique<base::DictionaryValue>();
   pacScriptDict->SetString(keys::kProxyConfigPacScriptData, kSamplePacScript);
   proxy_config.Set(keys::kProxyConfigPacScript, std::move(pacScriptDict));
 
@@ -177,7 +176,7 @@ TEST(ExtensionProxyApiHelpers, GetProxyRulesStringFromExtensionPref) {
   EXPECT_EQ(std::string(), out);
   EXPECT_EQ(std::string(), error);
 
-  auto proxy_rules = base::MakeUnique<base::DictionaryValue>();
+  auto proxy_rules = std::make_unique<base::DictionaryValue>();
   proxy_rules->Set(keys::field_name[1], CreateTestProxyServerDict("proxy1"));
   proxy_rules->Set(keys::field_name[2], CreateTestProxyServerDict("proxy2"));
   proxy_config.Set(keys::kProxyConfigRules, std::move(proxy_rules));
@@ -209,10 +208,10 @@ TEST(ExtensionProxyApiHelpers, GetBypassListFromExtensionPref) {
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 
-  auto bypass_list = base::MakeUnique<base::ListValue>();
+  auto bypass_list = std::make_unique<base::ListValue>();
   bypass_list->AppendString("host1");
   bypass_list->AppendString("host2");
-  auto proxy_rules = base::MakeUnique<base::DictionaryValue>();
+  auto proxy_rules = std::make_unique<base::DictionaryValue>();
   proxy_rules->Set(keys::kProxyConfigBypassList, std::move(bypass_list));
   proxy_config.Set(keys::kProxyConfigRules, std::move(proxy_rules));
 
@@ -330,7 +329,7 @@ TEST(ExtensionProxyApiHelpers, CreateProxyRulesDict) {
                 CreateTestProxyServerDict("http", "proxy3", 80));
   expected->Set("fallbackProxy",
                 CreateTestProxyServerDict("socks4", "proxy4", 80));
-  auto bypass_list = base::MakeUnique<base::ListValue>();
+  auto bypass_list = std::make_unique<base::ListValue>();
   bypass_list->AppendString("localhost");
   expected->Set(keys::kProxyConfigBypassList, std::move(bypass_list));
 
@@ -358,7 +357,7 @@ TEST(ExtensionProxyApiHelpers, CreateProxyRulesDictMultipleProxies) {
                 CreateTestProxyServerDict("http", "proxy3", 80));
   expected->Set("fallbackProxy",
                 CreateTestProxyServerDict("socks4", "proxy4", 80));
-  auto bypass_list = base::MakeUnique<base::ListValue>();
+  auto bypass_list = std::make_unique<base::ListValue>();
   bypass_list->AppendString("localhost");
   expected->Set(keys::kProxyConfigBypassList, std::move(bypass_list));
 
diff --git a/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc b/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc
index 61756b241fb..148b3cc4a0b 100644
--- a/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc
+++ b/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc
@@ -252,11 +252,11 @@ void ChromeRuntimeAPIDelegate::OpenURL(const GURL& uninstall_url) {
   if (!browser)
     browser = new Browser(Browser::CreateParams(profile, false));
 
-  chrome::NavigateParams params(
-      browser, uninstall_url, ui::PAGE_TRANSITION_CLIENT_REDIRECT);
+  NavigateParams params(browser, uninstall_url,
+                        ui::PAGE_TRANSITION_CLIENT_REDIRECT);
   params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   params.user_gesture = false;
-  chrome::Navigate(&params);
+  Navigate(&params);
 }
 
 bool ChromeRuntimeAPIDelegate::GetPlatformInfo(PlatformInfo* info) {
diff --git a/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate_unittest.cc b/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate_unittest.cc
index 355d8f518da..f005de4adc2 100644
--- a/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate_unittest.cc
@@ -9,7 +9,6 @@
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
-#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ -64,7 +63,7 @@ class TestEventRouter : public EventRouter {
 
 std::unique_ptr<KeyedService> TestEventRouterFactoryFunction(
     content::BrowserContext* context) {
-  return base::MakeUnique<TestEventRouter>(context);
+  return std::make_unique<TestEventRouter>(context);
 }
 
 // This class lets us intercept extension update checks and respond as if
@@ -160,7 +159,7 @@ class UpdateCheckResultCatcher {
 
   void OnResult(const RuntimeAPIDelegate::UpdateCheckResult& result) {
     EXPECT_EQ(nullptr, result_.get());
-    result_ = base::MakeUnique<RuntimeAPIDelegate::UpdateCheckResult>(
+    result_ = std::make_unique<RuntimeAPIDelegate::UpdateCheckResult>(
         result.success, result.response, result.version);
     if (run_loop_)
       run_loop_->Quit();
@@ -168,7 +167,7 @@ class UpdateCheckResultCatcher {
 
   std::unique_ptr<RuntimeAPIDelegate::UpdateCheckResult> WaitForResult() {
     if (!result_) {
-      run_loop_ = base::MakeUnique<base::RunLoop>();
+      run_loop_ = std::make_unique<base::RunLoop>();
       run_loop_->Run();
     }
     return std::move(result_);
@@ -192,14 +191,14 @@ class ChromeRuntimeAPIDelegateTest : public ExtensionServiceTestWithInstall {
 
     InitializeExtensionServiceWithUpdater();
     runtime_delegate_ =
-        base::MakeUnique<ChromeRuntimeAPIDelegate>(browser_context());
+        std::make_unique<ChromeRuntimeAPIDelegate>(browser_context());
     service()->updater()->SetExtensionCacheForTesting(nullptr);
     EventRouterFactory::GetInstance()->SetTestingFactory(
         browser_context(), &TestEventRouterFactoryFunction);
 
     // Setup the ExtensionService so that extension updates won't complete
     // installation until the extension is idle.
-    update_install_gate_ = base::MakeUnique<UpdateInstallGate>(service());
+    update_install_gate_ = std::make_unique<UpdateInstallGate>(service());
     service()->RegisterInstallGate(ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    update_install_gate_.get());
     static_cast<TestExtensionSystem*>(ExtensionSystem::Get(browser_context()))
diff --git a/chromium/chrome/browser/extensions/api/runtime/runtime_apitest.cc b/chromium/chrome/browser/extensions/api/runtime/runtime_apitest.cc
new file mode 100644
index 00000000000..2999bdd5c46
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/runtime/runtime_apitest.cc
@@ -0,0 +1,282 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/run_loop.h"
+#include "chrome/browser/apps/app_browsertest_util.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/extension_function_test_utils.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/test_extension_dir.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/test/browser_test_utils.h"
+#include "extensions/browser/api/runtime/runtime_api.h"
+#include "extensions/browser/blacklist_state.h"
+#include "extensions/browser/extension_dialog_auto_confirm.h"
+#include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/test_extension_registry_observer.h"
+#include "extensions/test/result_catcher.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "url/url_constants.h"
+
+// Tests the privileged components of chrome.runtime.
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeRuntimePrivileged) {
+  ASSERT_TRUE(RunExtensionTest("runtime/privileged")) << message_;
+}
+
+// Tests the unprivileged components of chrome.runtime.
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeRuntimeUnprivileged) {
+  ASSERT_TRUE(StartEmbeddedTestServer());
+  ASSERT_TRUE(
+      LoadExtension(test_data_dir_.AppendASCII("runtime/content_script")));
+
+  // The content script runs on this page.
+  extensions::ResultCatcher catcher;
+  ui_test_utils::NavigateToURL(browser(),
+                               embedded_test_server()->GetURL("/title1.html"));
+  EXPECT_TRUE(catcher.GetNextResult()) << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeRuntimeUninstallURL) {
+  // Auto-confirm the uninstall dialog.
+  extensions::ScopedTestDialogAutoConfirm auto_confirm(
+      extensions::ScopedTestDialogAutoConfirm::ACCEPT);
+  ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII("runtime")
+                                .AppendASCII("uninstall_url")
+                                .AppendASCII("sets_uninstall_url")));
+  ASSERT_TRUE(RunExtensionTest("runtime/uninstall_url")) << message_;
+}
+
+namespace extensions {
+
+namespace {
+
+const char kUninstallUrl[] = "http://www.google.com/";
+
+std::string GetActiveUrl(Browser* browser) {
+  return browser->tab_strip_model()
+      ->GetActiveWebContents()
+      ->GetLastCommittedURL()
+      .spec();
+}
+
+class RuntimeAPIUpdateTest : public ExtensionApiTest {
+ public:
+  RuntimeAPIUpdateTest() {}
+
+ protected:
+  void SetUpOnMainThread() override {
+    ExtensionApiTest::SetUpOnMainThread();
+    EXPECT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
+  }
+
+  struct ExtensionCRXData {
+    std::string unpacked_relative_path;
+    base::FilePath crx_path;
+    explicit ExtensionCRXData(const std::string& unpacked_relative_path)
+        : unpacked_relative_path(unpacked_relative_path) {}
+  };
+
+  void SetUpCRX(const std::string& root_dir,
+                const std::string& pem_filename,
+                std::vector<ExtensionCRXData>* crx_data_list) {
+    const base::FilePath test_dir = test_data_dir_.AppendASCII(root_dir);
+    const base::FilePath pem_path = test_dir.AppendASCII(pem_filename);
+    for (ExtensionCRXData& crx_data : *crx_data_list) {
+      crx_data.crx_path = PackExtensionWithOptions(
+          test_dir.AppendASCII(crx_data.unpacked_relative_path),
+          scoped_temp_dir_.GetPath().AppendASCII(
+              crx_data.unpacked_relative_path + ".crx"),
+          pem_path, base::FilePath());
+    }
+  }
+
+  bool CrashEnabledExtension(const std::string& extension_id) {
+    ExtensionHost* background_host =
+        ProcessManager::Get(browser()->profile())
+            ->GetBackgroundHostForExtension(extension_id);
+    if (!background_host)
+      return false;
+    content::CrashTab(background_host->host_contents());
+    return true;
+  }
+
+ private:
+  base::ScopedTempDir scoped_temp_dir_;
+
+  DISALLOW_COPY_AND_ASSIGN(RuntimeAPIUpdateTest);
+};
+
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeRuntimeOpenOptionsPage) {
+  ASSERT_TRUE(RunExtensionTest("runtime/open_options_page"));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeRuntimeOpenOptionsPageError) {
+  ASSERT_TRUE(RunExtensionTest("runtime/open_options_page_error"));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeRuntimeGetPlatformInfo) {
+  std::unique_ptr<base::Value> result(
+      extension_function_test_utils::RunFunctionAndReturnSingleResult(
+          new RuntimeGetPlatformInfoFunction(), "[]", browser()));
+  ASSERT_TRUE(result.get() != NULL);
+  base::DictionaryValue* dict =
+      extension_function_test_utils::ToDictionary(result.get());
+  ASSERT_TRUE(dict != NULL);
+  EXPECT_TRUE(dict->HasKey("os"));
+  EXPECT_TRUE(dict->HasKey("arch"));
+  EXPECT_TRUE(dict->HasKey("nacl_arch"));
+}
+
+// Tests chrome.runtime.getPackageDirectory with an app.
+IN_PROC_BROWSER_TEST_F(PlatformAppBrowserTest,
+                       ChromeRuntimeGetPackageDirectoryEntryApp) {
+  ASSERT_TRUE(RunPlatformAppTest("api_test/runtime/get_package_directory/app"))
+      << message_;
+}
+
+// Tests chrome.runtime.getPackageDirectory with an extension.
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest,
+                       ChromeRuntimeGetPackageDirectoryEntryExtension) {
+  ASSERT_TRUE(RunExtensionTest("runtime/get_package_directory/extension"))
+      << message_;
+}
+
+// Tests chrome.runtime.reload
+// This test is flaky: crbug.com/366181
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest, DISABLED_ChromeRuntimeReload) {
+  ExtensionRegistry* registry = ExtensionRegistry::Get(profile());
+  const char kManifest[] =
+      "{"
+      "  \"name\": \"reload\","
+      "  \"version\": \"1.0\","
+      "  \"background\": {"
+      "    \"scripts\": [\"background.js\"]"
+      "  },"
+      "  \"manifest_version\": 2"
+      "}";
+
+  TestExtensionDir dir;
+  dir.WriteManifest(kManifest);
+  dir.WriteFile(FILE_PATH_LITERAL("background.js"), "console.log('loaded');");
+
+  const Extension* extension = LoadExtension(dir.UnpackedPath());
+  ASSERT_TRUE(extension);
+  const std::string extension_id = extension->id();
+
+  // Somewhat arbitrary upper limit of 30 iterations. If the extension manages
+  // to reload itself that often without being terminated, the test fails
+  // anyway.
+  for (int i = 0; i < 30; i++) {
+    TestExtensionRegistryObserver unload_observer(registry, extension_id);
+    TestExtensionRegistryObserver load_observer(registry, extension_id);
+    ASSERT_TRUE(ExecuteScriptInBackgroundPageNoWait(
+        extension_id, "chrome.runtime.reload();"));
+    unload_observer.WaitForExtensionUnloaded();
+    base::RunLoop().RunUntilIdle();
+
+    if (registry->GetExtensionById(extension_id,
+                                   ExtensionRegistry::TERMINATED)) {
+      break;
+    } else {
+      load_observer.WaitForExtensionLoaded();
+      // We need to let other registry observers handle the notification to
+      // finish initialization
+      base::RunLoop().RunUntilIdle();
+      WaitForExtensionViewsToLoad();
+    }
+  }
+  ASSERT_TRUE(
+      registry->GetExtensionById(extension_id, ExtensionRegistry::TERMINATED));
+}
+
+// Tests that updating a terminated extension sends runtime.onInstalled event
+// with correct previousVersion.
+// Regression test for https://crbug.com/724563.
+IN_PROC_BROWSER_TEST_F(RuntimeAPIUpdateTest,
+                       TerminatedExtensionUpdateHasCorrectPreviousVersion) {
+  std::vector<ExtensionCRXData> data;
+  data.emplace_back("v1");
+  data.emplace_back("v2");
+  SetUpCRX("runtime/update_terminated_extension", "pem.pem", &data);
+
+  ExtensionId extension_id;
+  {
+    // Install version 1 of the extension.
+    ResultCatcher catcher;
+    const int expected_change = 1;
+    const Extension* extension_v1 =
+        InstallExtension(data[0].crx_path, expected_change);
+    extension_id = extension_v1->id();
+    ASSERT_TRUE(extension_v1);
+    EXPECT_TRUE(catcher.GetNextResult());
+  }
+  ASSERT_TRUE(CrashEnabledExtension(extension_id));
+  {
+    // Update to version 2, expect runtime.onInstalled with
+    // previousVersion = '1'.
+    ResultCatcher catcher;
+    const int expected_change = 1;
+    const Extension* extension_v2 =
+        UpdateExtension(extension_id, data[1].crx_path, expected_change);
+    ASSERT_TRUE(extension_v2);
+    EXPECT_TRUE(catcher.GetNextResult());
+  }
+}
+
+// Tests that when a blacklisted extension with a set uninstall url is
+// uninstalled, its uninstall url does not open.
+IN_PROC_BROWSER_TEST_F(ExtensionApiTest,
+                       DoNotOpenUninstallUrlForBlacklistedExtensions) {
+  // Load an extension that has set an uninstall url.
+  scoped_refptr<const extensions::Extension> extension =
+      LoadExtension(test_data_dir_.AppendASCII("runtime")
+                        .AppendASCII("uninstall_url")
+                        .AppendASCII("sets_uninstall_url"));
+
+  ASSERT_TRUE(extension.get());
+  extension_service()->AddExtension(extension.get());
+  ASSERT_TRUE(extension_service()->IsExtensionEnabled(extension->id()));
+
+  // Uninstall the extension and expect its uninstall url to open.
+  extension_service()->UninstallExtension(
+      extension->id(), extensions::UNINSTALL_REASON_USER_INITIATED, NULL);
+  TabStripModel* tabs = browser()->tab_strip_model();
+
+  EXPECT_EQ(2, tabs->count());
+  content::WaitForLoadStop(tabs->GetActiveWebContents());
+  // Verify the uninstall url
+  EXPECT_EQ(kUninstallUrl, GetActiveUrl(browser()));
+
+  // Close the tab pointing to the uninstall url.
+  tabs->CloseWebContentsAt(tabs->active_index(), 0);
+  EXPECT_EQ(1, tabs->count());
+  EXPECT_EQ("about:blank", GetActiveUrl(browser()));
+
+  // Load the same extension again, except blacklist it after installation.
+  extension = LoadExtension(test_data_dir_.AppendASCII("runtime")
+                                .AppendASCII("uninstall_url")
+                                .AppendASCII("sets_uninstall_url"));
+  extension_service()->AddExtension(extension.get());
+  ASSERT_TRUE(extension_service()->IsExtensionEnabled(extension->id()));
+
+  // Blacklist extension.
+  extensions::ExtensionPrefs::Get(profile())->SetExtensionBlacklistState(
+      extension->id(), extensions::BlacklistState::BLACKLISTED_MALWARE);
+
+  // Uninstalling a blacklisted extension should not open its uninstall url.
+  TestExtensionRegistryObserver observer(ExtensionRegistry::Get(profile()),
+                                         extension->id());
+  extension_service()->UninstallExtension(
+      extension->id(), extensions::UNINSTALL_REASON_USER_INITIATED, NULL);
+  observer.WaitForExtensionUninstalled();
+
+  EXPECT_EQ(1, tabs->count());
+  content::WaitForLoadStop(tabs->GetActiveWebContents());
+  EXPECT_EQ(url::kAboutBlankURL, GetActiveUrl(browser()));
+}
+
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/screenlock_private/screenlock_private_api.cc b/chromium/chrome/browser/extensions/api/screenlock_private/screenlock_private_api.cc
index 6eb32c1c891..c2bef6dbe46 100644
--- a/chromium/chrome/browser/extensions/api/screenlock_private/screenlock_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/screenlock_private/screenlock_private_api.cc
@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/chrome_proximity_auth_client.h"
@@ -56,7 +55,7 @@ ScreenlockPrivateGetLockedFunction::ScreenlockPrivateGetLockedFunction() {}
 ScreenlockPrivateGetLockedFunction::~ScreenlockPrivateGetLockedFunction() {}
 
 bool ScreenlockPrivateGetLockedFunction::RunAsync() {
-  SetResult(base::MakeUnique<base::Value>(
+  SetResult(std::make_unique<base::Value>(
       proximity_auth::ScreenlockBridge::Get()->IsLocked()));
   SendResponse(error_.empty());
   return true;
@@ -121,14 +120,14 @@ void ScreenlockPrivateEventRouter::OnScreenDidLock(
     proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   DispatchEvent(events::SCREENLOCK_PRIVATE_ON_CHANGED,
                 screenlock::OnChanged::kEventName,
-                base::MakeUnique<base::Value>(true));
+                std::make_unique<base::Value>(true));
 }
 
 void ScreenlockPrivateEventRouter::OnScreenDidUnlock(
     proximity_auth::ScreenlockBridge::LockHandler::ScreenType screen_type) {
   DispatchEvent(events::SCREENLOCK_PRIVATE_ON_CHANGED,
                 screenlock::OnChanged::kEventName,
-                base::MakeUnique<base::Value>(false));
+                std::make_unique<base::Value>(false));
 }
 
 void ScreenlockPrivateEventRouter::OnFocusedUserChanged(
diff --git a/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc b/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc
index 1c372a7433d..aba5cc99f59 100644
--- a/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc
+++ b/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc
@@ -6,12 +6,12 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.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"
@@ -154,7 +154,7 @@ SessionsGetRecentlyClosedFunction::CreateWindowModel(
     const sessions::TabRestoreService::Window& window) {
   DCHECK(!window.tabs.empty());
 
-  auto tabs = base::MakeUnique<std::vector<tabs::Tab>>();
+  auto tabs = std::make_unique<std::vector<tabs::Tab>>();
   for (const auto& tab : window.tabs)
     tabs->push_back(
         CreateTabModel(*tab, tab->tabstrip_index == window.selected_tab_index));
@@ -570,7 +570,7 @@ SessionsEventRouter::~SessionsEventRouter() {
 void SessionsEventRouter::TabRestoreServiceChanged(
     sessions::TabRestoreService* service) {
   std::unique_ptr<base::ListValue> args(new base::ListValue());
-  EventRouter::Get(profile_)->BroadcastEvent(base::MakeUnique<Event>(
+  EventRouter::Get(profile_)->BroadcastEvent(std::make_unique<Event>(
       events::SESSIONS_ON_CHANGED, api::sessions::OnChanged::kEventName,
       std::move(args)));
 }
diff --git a/chromium/chrome/browser/extensions/api/sessions/sessions_apitest.cc b/chromium/chrome/browser/extensions/api/sessions/sessions_apitest.cc
index a0e02b75501..6f68a4cd4d0 100644
--- a/chromium/chrome/browser/extensions/api/sessions/sessions_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/sessions/sessions_apitest.cc
@@ -4,6 +4,7 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ -195,7 +196,7 @@ std::unique_ptr<KeyedService> ExtensionSessionsTest::BuildProfileSyncService(
   browser_sync::ProfileSyncServiceMock* sync_service =
       new browser_sync::ProfileSyncServiceMock(
           CreateProfileSyncServiceParamsForTest(
-              base::MakeUnique<browser_sync::ChromeSyncClient>(profile),
+              std::make_unique<browser_sync::ChromeSyncClient>(profile),
               profile));
   static_cast<browser_sync::ChromeSyncClient*>(sync_service->GetSyncClient())
       ->SetSyncApiComponentFactoryForTesting(std::move(factory));
diff --git a/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc b/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc
index 0a2343bc02c..dd1e77d785e 100644
--- a/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc
+++ b/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc
@@ -9,7 +9,6 @@
 #include <utility>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/preference/preference_api.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
@@ -61,7 +60,7 @@ std::unique_ptr<TemplateURLData> ConvertSearchProvider(
   }
 
   if (!data)
-    data = base::MakeUnique<TemplateURLData>();
+    data = std::make_unique<TemplateURLData>();
 
   if (search_provider.name)
     data->SetShortName(base::UTF8ToUTF16(*search_provider.name));
@@ -154,15 +153,15 @@ void SettingsOverridesAPI::OnExtensionLoaded(
         ExtensionPrefs::Get(profile_)->GetInstallParam(extension->id());
     if (settings->homepage) {
       SetPref(extension->id(), prefs::kHomePage,
-              base::MakeUnique<base::Value>(SubstituteInstallParam(
+              std::make_unique<base::Value>(SubstituteInstallParam(
                   settings->homepage->spec(), install_parameter)));
       SetPref(extension->id(), prefs::kHomePageIsNewTabPage,
-              base::MakeUnique<base::Value>(false));
+              std::make_unique<base::Value>(false));
     }
     if (!settings->startup_pages.empty()) {
       SetPref(
           extension->id(), prefs::kRestoreOnStartup,
-          base::MakeUnique<base::Value>(SessionStartupPref::kPrefValueURLs));
+          std::make_unique<base::Value>(SessionStartupPref::kPrefValueURLs));
       if (settings->startup_pages.size() > 1) {
         VLOG(1) << extensions::ErrorUtils::FormatErrorMessage(
                        kManyStartupPagesWarning,
@@ -180,7 +179,7 @@ void SettingsOverridesAPI::OnExtensionLoaded(
       // all search engines.
       if (settings->search_engine->is_default) {
         SetPref(extension->id(), prefs::kDefaultSearchProviderEnabled,
-                base::MakeUnique<base::Value>(true));
+                std::make_unique<base::Value>(true));
       } else {
         UnsetPref(extension->id(), prefs::kDefaultSearchProviderEnabled);
       }
@@ -228,7 +227,7 @@ void SettingsOverridesAPI::RegisterSearchProvider(
   std::string install_parameter = prefs->GetInstallParam(extension->id());
   std::unique_ptr<TemplateURLData> data = ConvertSearchProvider(
       profile_->GetPrefs(), *settings->search_engine, install_parameter);
-  auto turl = base::MakeUnique<TemplateURL>(
+  auto turl = std::make_unique<TemplateURL>(
       *data, TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, extension->id(),
       prefs->GetInstallTime(extension->id()),
       settings->search_engine->is_default);
diff --git a/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc b/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc
index 56d30db8f51..a612b2c1250 100644
--- a/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
@@ -30,7 +32,7 @@ const int kTestExtensionPrepopulatedId = 1;
 // TemplateURLData with search engines settings from test extension manifest.
 // chrome/test/data/extensions/settings_override/manifest.json
 std::unique_ptr<TemplateURLData> TestExtensionSearchEngine(PrefService* prefs) {
-  auto result = base::MakeUnique<TemplateURLData>();
+  auto result = std::make_unique<TemplateURLData>();
   result->SetShortName(base::ASCIIToUTF16("name.de"));
   result->SetKeyword(base::ASCIIToUTF16("keyword.de"));
   result->SetURL("http://www.foo.de/s?q={searchTerms}&id=10");
diff --git a/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.cc b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.cc
new file mode 100644
index 00000000000..65c4c99243e
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.cc
@@ -0,0 +1,112 @@
+// 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/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.h"
+
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
+#include "chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/extensions/api/settings_private.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/pref_service.h"
+
+namespace extensions {
+
+namespace settings_api = api::settings_private;
+
+namespace settings_private {
+namespace {
+
+// Implements kResolveTimezoneByGeolocationMethodShort generated preference.
+class GeneratedResolveTimezoneByGeolocationMethodShort
+    : public GeneratedTimeZonePrefBase {
+ public:
+  explicit GeneratedResolveTimezoneByGeolocationMethodShort(Profile* profile);
+  ~GeneratedResolveTimezoneByGeolocationMethodShort() override;
+
+  // GeneratedPrefsChromeOSImpl implementation:
+  std::unique_ptr<settings_api::PrefObject> GetPrefObject() const override;
+  SetPrefResult SetPref(const base::Value* value) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(GeneratedResolveTimezoneByGeolocationMethodShort);
+};
+
+GeneratedResolveTimezoneByGeolocationMethodShort::
+    GeneratedResolveTimezoneByGeolocationMethodShort(Profile* profile)
+    : GeneratedTimeZonePrefBase(kResolveTimezoneByGeolocationMethodShort,
+                                profile) {}
+
+GeneratedResolveTimezoneByGeolocationMethodShort::
+    ~GeneratedResolveTimezoneByGeolocationMethodShort() = default;
+
+std::unique_ptr<settings_api::PrefObject>
+GeneratedResolveTimezoneByGeolocationMethodShort::GetPrefObject() const {
+  std::unique_ptr<settings_api::PrefObject> pref_object =
+      std::make_unique<settings_api::PrefObject>();
+
+  pref_object->key = pref_name_;
+  pref_object->type = settings_api::PREF_TYPE_NUMBER;
+  pref_object->value = std::make_unique<base::Value>(static_cast<int>(
+      g_browser_process->platform_part()
+          ->GetTimezoneResolverManager()
+          ->GetEffectiveUserTimeZoneResolveMethod(profile_->GetPrefs(), true)));
+  UpdateTimeZonePrefControlledBy(pref_object.get());
+
+  return pref_object;
+}
+
+SetPrefResult GeneratedResolveTimezoneByGeolocationMethodShort::SetPref(
+    const base::Value* value) {
+  if (!value->is_int())
+    return SetPrefResult::PREF_TYPE_MISMATCH;
+
+  // Check if preference is policy or primary-user controlled.
+  if (chromeos::system::TimeZoneResolverManager::
+          IsTimeZoneResolutionPolicyControlled() ||
+      !profile_->IsSameProfile(ProfileManager::GetPrimaryUserProfile())) {
+    return SetPrefResult::PREF_NOT_MODIFIABLE;
+  }
+
+  // Check if automatic time zone detection is disabled.
+  // (kResolveTimezoneByGeolocationOnOff must be modified first.)
+  if (!g_browser_process->platform_part()
+           ->GetTimezoneResolverManager()
+           ->TimeZoneResolverShouldBeRunning()) {
+    return SetPrefResult::PREF_NOT_MODIFIABLE;
+  }
+
+  const chromeos::system::TimeZoneResolverManager::TimeZoneResolveMethod
+      new_value = chromeos::system::TimeZoneResolverManager::
+          TimeZoneResolveMethodFromInt(value->GetInt());
+  const chromeos::system::TimeZoneResolverManager::TimeZoneResolveMethod
+      current_value = g_browser_process->platform_part()
+                          ->GetTimezoneResolverManager()
+                          ->GetEffectiveUserTimeZoneResolveMethod(
+                              profile_->GetPrefs(), true);
+  if (new_value == current_value)
+    return SetPrefResult::SUCCESS;
+
+  profile_->GetPrefs()->SetInteger(::prefs::kResolveTimezoneByGeolocationMethod,
+                                   static_cast<int>(new_value));
+
+  return SetPrefResult::SUCCESS;
+}
+
+}  // anonymous namespace
+
+const char kResolveTimezoneByGeolocationMethodShort[] =
+    "generated.resolve_timezone_by_geolocation_method_short";
+
+std::unique_ptr<GeneratedPref>
+CreateGeneratedResolveTimezoneByGeolocationMethodShort(Profile* profile) {
+  return std::make_unique<GeneratedResolveTimezoneByGeolocationMethodShort>(
+      profile);
+}
+
+}  // namespace settings_private
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.h b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.h
new file mode 100644
index 00000000000..7867b2f7b57
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.h
@@ -0,0 +1,28 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_CHROMEOS_RESOLVE_TIME_ZONE_BY_GEOLOCATION_METHOD_SHORT_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_CHROMEOS_RESOLVE_TIME_ZONE_BY_GEOLOCATION_METHOD_SHORT_H_
+
+#include <memory>
+
+class Profile;
+
+namespace extensions {
+namespace settings_private {
+
+class GeneratedPref;
+
+// Time zone detection method (e.g. using general location vs. accurate
+// location).
+extern const char kResolveTimezoneByGeolocationMethodShort[];
+
+// Constructor for kResolveTimezoneByGeolocationMethodShort preference.
+std::unique_ptr<GeneratedPref>
+CreateGeneratedResolveTimezoneByGeolocationMethodShort(Profile* profile);
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_CHROMEOS_RESOLVE_TIME_ZONE_BY_GEOLOCATION_METHOD_SHORT_H_
diff --git a/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.cc b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.cc
new file mode 100644
index 00000000000..f261f0608e3
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.cc
@@ -0,0 +1,104 @@
+// 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/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.h"
+
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
+#include "chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/extensions/api/settings_private.h"
+#include "chrome/common/pref_names.h"
+#include "components/prefs/pref_service.h"
+#include "components/user_manager/user_manager.h"
+
+namespace extensions {
+
+namespace settings_api = api::settings_private;
+
+namespace settings_private {
+namespace {
+
+// Implements kResolveTimezoneByGeolocationOnOff generated preference.
+class GeneratedResolveTimezoneByGeolocationOnOff
+    : public GeneratedTimeZonePrefBase {
+ public:
+  explicit GeneratedResolveTimezoneByGeolocationOnOff(Profile* profile);
+  ~GeneratedResolveTimezoneByGeolocationOnOff() override;
+
+  // GeneratedPref implementation:
+  std::unique_ptr<settings_api::PrefObject> GetPrefObject() const override;
+  SetPrefResult SetPref(const base::Value* value) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(GeneratedResolveTimezoneByGeolocationOnOff);
+};
+
+GeneratedResolveTimezoneByGeolocationOnOff::
+    GeneratedResolveTimezoneByGeolocationOnOff(Profile* profile)
+    : GeneratedTimeZonePrefBase(kResolveTimezoneByGeolocationOnOff, profile) {}
+
+GeneratedResolveTimezoneByGeolocationOnOff::
+    ~GeneratedResolveTimezoneByGeolocationOnOff() = default;
+
+std::unique_ptr<settings_api::PrefObject>
+GeneratedResolveTimezoneByGeolocationOnOff::GetPrefObject() const {
+  std::unique_ptr<settings_api::PrefObject> pref_object =
+      std::make_unique<settings_api::PrefObject>();
+
+  pref_object->key = pref_name_;
+  pref_object->type = settings_api::PREF_TYPE_BOOLEAN;
+  pref_object->value =
+      std::make_unique<base::Value>(g_browser_process->platform_part()
+                                        ->GetTimezoneResolverManager()
+                                        ->TimeZoneResolverShouldBeRunning());
+
+  UpdateTimeZonePrefControlledBy(pref_object.get());
+
+  return pref_object;
+}
+
+SetPrefResult GeneratedResolveTimezoneByGeolocationOnOff::SetPref(
+    const base::Value* value) {
+  if (!value->is_bool())
+    return SetPrefResult::PREF_TYPE_MISMATCH;
+
+  // Check if preference is policy or primary-user controlled.
+  if (chromeos::system::TimeZoneResolverManager::
+          IsTimeZoneResolutionPolicyControlled() ||
+      !profile_->IsSameProfile(ProfileManager::GetPrimaryUserProfile())) {
+    return SetPrefResult::PREF_NOT_MODIFIABLE;
+  }
+
+  const bool new_value = value->GetBool();
+  const bool current_value = g_browser_process->platform_part()
+                                 ->GetTimezoneResolverManager()
+                                 ->TimeZoneResolverShouldBeRunning();
+  if (new_value == current_value)
+    return SetPrefResult::SUCCESS;
+
+  profile_->GetPrefs()->SetInteger(
+      ::prefs::kResolveTimezoneByGeolocationMethod,
+      static_cast<int>(new_value ? chromeos::system::TimeZoneResolverManager::
+                                       TimeZoneResolveMethod::IP_ONLY
+                                 : chromeos::system::TimeZoneResolverManager::
+                                       TimeZoneResolveMethod::DISABLED));
+
+  return SetPrefResult::SUCCESS;
+}
+
+}  //  anonymous namespace
+
+const char kResolveTimezoneByGeolocationOnOff[] =
+    "generated.resolve_timezone_by_geolocation_on_off";
+
+std::unique_ptr<GeneratedPref> CreateGeneratedResolveTimezoneByGeolocationOnOff(
+    Profile* profile) {
+  return std::make_unique<GeneratedResolveTimezoneByGeolocationOnOff>(profile);
+}
+
+}  // namespace settings_private
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.h b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.h
new file mode 100644
index 00000000000..099f5f7b181
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.h
@@ -0,0 +1,27 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_CHROMEOS_RESOLVE_TIME_ZONE_BY_GEOLOCATION_ON_OFF_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_CHROMEOS_RESOLVE_TIME_ZONE_BY_GEOLOCATION_ON_OFF_H_
+
+#include <memory>
+
+class Profile;
+
+namespace extensions {
+namespace settings_private {
+
+class GeneratedPref;
+
+// Whether time zone detection by geolocation is enabled.
+extern const char kResolveTimezoneByGeolocationOnOff[];
+
+// Constructor for kResolveTimezoneByGeolocationOnOff preference.
+std::unique_ptr<GeneratedPref> CreateGeneratedResolveTimezoneByGeolocationOnOff(
+    Profile* profile);
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_CHROMEOS_RESOLVE_TIME_ZONE_BY_GEOLOCATION_ON_OFF_H_
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_pref.cc b/chromium/chrome/browser/extensions/api/settings_private/generated_pref.cc
new file mode 100644
index 00000000000..b0308f67c07
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_pref.cc
@@ -0,0 +1,30 @@
+// 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/extensions/api/settings_private/generated_pref.h"
+
+namespace extensions {
+namespace settings_private {
+
+GeneratedPref::Observer::Observer() = default;
+GeneratedPref::Observer::~Observer() = default;
+
+GeneratedPref::GeneratedPref() = default;
+GeneratedPref::~GeneratedPref() = default;
+
+void GeneratedPref::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void GeneratedPref::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void GeneratedPref::NotifyObservers(const std::string& pref_name) {
+  for (Observer& observer : observers_)
+    observer.OnGeneratedPrefChanged(pref_name);
+}
+
+}  // namespace settings_private
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_pref.h b/chromium/chrome/browser/extensions/api/settings_private/generated_pref.h
new file mode 100644
index 00000000000..a634903329b
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_pref.h
@@ -0,0 +1,74 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREF_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREF_H_
+
+#include <memory>
+#include <string>
+#include "base/macros.h"
+#include "base/observer_list.h"
+#include "chrome/browser/extensions/api/settings_private/prefs_util_enums.h"
+
+namespace base {
+class Value;
+}
+
+namespace extensions {
+namespace api {
+namespace settings_private {
+struct PrefObject;
+}  // namespace settings_private
+}  // namespace api
+
+namespace settings_private {
+
+// Base class for generated preference implementation.
+// These are the "preferences" that exist in settings_private API only
+// to simplify creating Settings UI for something not directly attached to
+// user preference.
+class GeneratedPref {
+ public:
+  class Observer {
+   public:
+    Observer();
+    virtual ~Observer();
+
+    // This method is called to notify observer that visible value
+    // of the preference has changed.
+    virtual void OnGeneratedPrefChanged(const std::string& pref_name) = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Observer);
+  };
+
+  virtual ~GeneratedPref();
+
+  // Returns fully populated PrefObject.
+  virtual std::unique_ptr<api::settings_private::PrefObject> GetPrefObject()
+      const = 0;
+
+  // Updates "preference" value.
+  virtual SetPrefResult SetPref(const base::Value* value) = 0;
+
+  // Modify observer list.
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+ protected:
+  GeneratedPref();
+
+  // Call this when the pref value changes.
+  void NotifyObservers(const std::string& pref_name);
+
+ private:
+  base::ObserverList<Observer> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(GeneratedPref);
+};
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREF_H_
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_prefs.cc b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs.cc
new file mode 100644
index 00000000000..dff08441a4e
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs.cc
@@ -0,0 +1,81 @@
+// 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/extensions/api/settings_private/generated_prefs.h"
+
+#include "base/callback.h"
+#include "build/build_config.h"
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
+#include "chrome/browser/extensions/api/settings_private/prefs_util_enums.h"
+#include "chrome/common/extensions/api/settings_private.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.h"
+#include "chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.h"
+#endif
+
+namespace extensions {
+namespace settings_private {
+
+GeneratedPrefs::GeneratedPrefs(Profile* profile) {
+#if defined(OS_CHROMEOS)
+  prefs_[kResolveTimezoneByGeolocationOnOff] =
+      CreateGeneratedResolveTimezoneByGeolocationOnOff(profile);
+  prefs_[kResolveTimezoneByGeolocationMethodShort] =
+      CreateGeneratedResolveTimezoneByGeolocationMethodShort(profile);
+#endif
+}
+
+GeneratedPrefs::~GeneratedPrefs() = default;
+
+bool GeneratedPrefs::HasPref(const std::string& pref_name) const {
+  return FindPrefImpl(pref_name) != nullptr;
+}
+
+std::unique_ptr<api::settings_private::PrefObject> GeneratedPrefs::GetPref(
+    const std::string& pref_name) const {
+  GeneratedPref* impl = FindPrefImpl(pref_name);
+  if (!impl)
+    return nullptr;
+
+  return impl->GetPrefObject();
+}
+
+SetPrefResult GeneratedPrefs::SetPref(const std::string& pref_name,
+                                      const base::Value* value) {
+  GeneratedPref* impl = FindPrefImpl(pref_name);
+  if (!impl)
+    return SetPrefResult::PREF_NOT_FOUND;
+
+  return impl->SetPref(value);
+}
+
+void GeneratedPrefs::AddObserver(const std::string& pref_name,
+                                 GeneratedPref::Observer* observer) {
+  GeneratedPref* impl = FindPrefImpl(pref_name);
+  CHECK(impl);
+
+  impl->AddObserver(observer);
+}
+
+void GeneratedPrefs::RemoveObserver(const std::string& pref_name,
+                                    GeneratedPref::Observer* observer) {
+  GeneratedPref* impl = FindPrefImpl(pref_name);
+  if (!impl)
+    return;
+
+  impl->RemoveObserver(observer);
+}
+
+GeneratedPref* GeneratedPrefs::FindPrefImpl(
+    const std::string& pref_name) const {
+  const PrefsMap::const_iterator it = prefs_.find(pref_name);
+  if (it == prefs_.end())
+    return nullptr;
+
+  return it->second.get();
+}
+
+}  // namespace settings_private
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_prefs.h b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs.h
new file mode 100644
index 00000000000..fef9247c66b
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs.h
@@ -0,0 +1,73 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREFS_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREFS_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "base/macros.h"
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
+#include "chrome/browser/extensions/api/settings_private/prefs_util_enums.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+class Profile;
+
+namespace base {
+class Value;
+}
+
+namespace extensions {
+namespace api {
+namespace settings_private {
+struct PrefObject;
+}  // namespace settings_private
+}  // namespace api
+
+namespace settings_private {
+
+// This is a "store" for virtual preferences that exist only for
+// api::settings_private. These are used to control Chrome Settings UI elements
+// not directly attached to user preferences.
+class GeneratedPrefs : public KeyedService {
+ public:
+  // Preference name to implementation map.
+  using PrefsMap =
+      std::unordered_map<std::string, std::unique_ptr<GeneratedPref>>;
+
+  explicit GeneratedPrefs(Profile* profile);
+  ~GeneratedPrefs() override;
+
+  // Returns true if preference is supported.
+  bool HasPref(const std::string& pref_name) const;
+
+  // Returns fully populated PrefObject or nullptr if not supported.
+  std::unique_ptr<api::settings_private::PrefObject> GetPref(
+      const std::string& pref_name) const;
+
+  // Updates preference value.
+  SetPrefResult SetPref(const std::string& pref_name, const base::Value* value);
+
+  // Modify list of observers for the given preference.
+  void AddObserver(const std::string& pref_name,
+                   GeneratedPref::Observer* observer);
+  void RemoveObserver(const std::string& pref_name,
+                      GeneratedPref::Observer* observer);
+
+ private:
+  // Returns preference implementation or nullptr if not found.
+  GeneratedPref* FindPrefImpl(const std::string& pref_name) const;
+
+  // Known preference map.
+  PrefsMap prefs_;
+
+  DISALLOW_COPY_AND_ASSIGN(GeneratedPrefs);
+};
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREFS_H_
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_prefs_factory.cc b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs_factory.cc
new file mode 100644
index 00000000000..fa90ade78a3
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs_factory.cc
@@ -0,0 +1,40 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/extensions/api/settings_private/generated_prefs_factory.h"
+
+#include "chrome/browser/extensions/api/settings_private/generated_prefs.h"
+#include "chrome/browser/profiles/incognito_helpers.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+
+namespace extensions {
+namespace settings_private {
+
+// static
+GeneratedPrefs* GeneratedPrefsFactory::GetForBrowserContext(
+    content::BrowserContext* browser_context) {
+  return static_cast<GeneratedPrefs*>(
+      GetInstance()->GetServiceForBrowserContext(browser_context, true));
+}
+
+// static
+GeneratedPrefsFactory* GeneratedPrefsFactory::GetInstance() {
+  return base::Singleton<GeneratedPrefsFactory>::get();
+}
+
+GeneratedPrefsFactory::GeneratedPrefsFactory()
+    : BrowserContextKeyedServiceFactory(
+          "GeneratedPrefs",
+          BrowserContextDependencyManager::GetInstance()) {}
+
+GeneratedPrefsFactory::~GeneratedPrefsFactory() {}
+
+KeyedService* GeneratedPrefsFactory::BuildServiceInstanceFor(
+    content::BrowserContext* profile) const {
+  return new GeneratedPrefs(static_cast<Profile*>(profile));
+}
+
+}  // namespace settings_private
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_prefs_factory.h b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs_factory.h
new file mode 100644
index 00000000000..c435e5b2784
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_prefs_factory.h
@@ -0,0 +1,41 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREFS_FACTORY_H__
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREFS_FACTORY_H__
+
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+namespace extensions {
+namespace settings_private {
+
+class GeneratedPrefs;
+
+// BrowserContextKeyedServiceFactory for GeneratedPrefs.
+class GeneratedPrefsFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  static GeneratedPrefs* GetForBrowserContext(
+      content::BrowserContext* browser_context);
+
+  static GeneratedPrefsFactory* GetInstance();
+
+ private:
+  friend struct base::DefaultSingletonTraits<GeneratedPrefsFactory>;
+
+  GeneratedPrefsFactory();
+  ~GeneratedPrefsFactory() override;
+
+  // BrowserContextKeyedBaseFactory implementation.
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* profile) const override;
+
+  DISALLOW_COPY_AND_ASSIGN(GeneratedPrefsFactory);
+};
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_PREFS_FACTORY_H__
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.cc b/chromium/chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.cc
new file mode 100644
index 00000000000..1e3d56309af
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.cc
@@ -0,0 +1,56 @@
+// 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/extensions/api/settings_private/generated_time_zone_pref_base.h"
+
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/common/extensions/api/settings_private.h"
+#include "components/user_manager/user_manager.h"
+
+namespace extensions {
+
+namespace settings_api = api::settings_private;
+
+namespace settings_private {
+
+GeneratedTimeZonePrefBase::GeneratedTimeZonePrefBase(
+    const std::string& pref_name,
+    Profile* profile)
+    : pref_name_(pref_name), profile_(profile) {
+  g_browser_process->platform_part()->GetTimezoneResolverManager()->AddObserver(
+      this);
+}
+
+GeneratedTimeZonePrefBase::~GeneratedTimeZonePrefBase() {
+  g_browser_process->platform_part()
+      ->GetTimezoneResolverManager()
+      ->RemoveObserver(this);
+}
+
+void GeneratedTimeZonePrefBase::OnTimeZoneResolverUpdated() {
+  NotifyObservers(pref_name_);
+}
+
+void GeneratedTimeZonePrefBase::UpdateTimeZonePrefControlledBy(
+    settings_api::PrefObject* out_pref) const {
+  if (chromeos::system::TimeZoneResolverManager::
+          IsTimeZoneResolutionPolicyControlled()) {
+    out_pref->controlled_by = settings_api::CONTROLLED_BY_DEVICE_POLICY;
+    out_pref->enforcement = settings_api::ENFORCEMENT_ENFORCED;
+  } else if (!profile_->IsSameProfile(
+                 ProfileManager::GetPrimaryUserProfile())) {
+    out_pref->controlled_by = settings_api::CONTROLLED_BY_PRIMARY_USER;
+    out_pref->controlled_by_name = std::make_unique<std::string>(
+        user_manager::UserManager::Get()->GetPrimaryUser()->GetDisplayEmail());
+    out_pref->enforcement = settings_api::ENFORCEMENT_ENFORCED;
+  }
+  // Time zone settings can be policy-bound (for all users), or primary-user
+  // bound (for secondary users in multiprofile mode). Otherwise do not modify
+  // default values.
+}
+
+}  // namespace settings_private
+}  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.h b/chromium/chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.h
new file mode 100644
index 00000000000..99ec2946140
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/generated_time_zone_pref_base.h
@@ -0,0 +1,45 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_TIME_ZONE_PREF_BASE_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_TIME_ZONE_PREF_BASE_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
+
+class Profile;
+
+namespace extensions {
+namespace settings_private {
+
+// Base class for several generated Time Zone preferences.
+class GeneratedTimeZonePrefBase
+    : public GeneratedPref,
+      public chromeos::system::TimeZoneResolverManager::Observer {
+ public:
+  ~GeneratedTimeZonePrefBase() override;
+
+  // chromeos::system::TimeZoneResolverManager::Observer
+  void OnTimeZoneResolverUpdated() override;
+
+ protected:
+  GeneratedTimeZonePrefBase(const std::string& pref_name, Profile* profile);
+
+  void UpdateTimeZonePrefControlledBy(
+      api::settings_private::PrefObject* out_pref) const;
+
+  const std::string pref_name_;
+
+  Profile* const profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(GeneratedTimeZonePrefBase);
+};
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_GENERATED_TIME_ZONE_PREF_BASE_H_
diff --git a/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc b/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc
index 7b73936b860..12188832837 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc
+++ b/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc
@@ -6,6 +6,8 @@
 
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/settings_private/generated_prefs.h"
+#include "chrome/browser/extensions/api/settings_private/generated_prefs_factory.h"
 #include "chrome/browser/extensions/chrome_extension_function.h"
 #include "chrome/browser/extensions/settings_api_helpers.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
@@ -40,8 +42,9 @@
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
-#include "chrome/browser/chromeos/system/timezone_resolver_manager.h"
 #include "chrome/browser/chromeos/system/timezone_util.h"
+#include "chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_method_short.h"
+#include "chrome/browser/extensions/api/settings_private/chromeos_resolve_time_zone_by_geolocation_on_off.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "components/arc/arc_prefs.h"
 #include "ui/chromeos/events/pref_names.h"
@@ -76,7 +79,7 @@ bool IsCrosSettingReadOnly(const std::string& pref_name) {
 
 namespace extensions {
 
-namespace settings_private = api::settings_private;
+namespace settings_api = api::settings_private;
 
 PrefsUtil::PrefsUtil(Profile* profile) : profile_(profile) {}
 
@@ -94,386 +97,391 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() {
 
   // Miscellaneous
   (*s_whitelist)[::prefs::kAlternateErrorPagesEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[autofill::prefs::kAutofillEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[bookmarks::prefs::kShowBookmarkBar] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   (*s_whitelist)[::prefs::kUseCustomChromeFrame] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #endif
   (*s_whitelist)[::prefs::kShowHomeButton] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Appearance settings.
   (*s_whitelist)[::prefs::kCurrentThemeID] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   (*s_whitelist)[::prefs::kUsesSystemTheme] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #endif
-  (*s_whitelist)[::prefs::kHomePage] =
-      settings_private::PrefType::PREF_TYPE_URL;
+  (*s_whitelist)[::prefs::kHomePage] = settings_api::PrefType::PREF_TYPE_URL;
   (*s_whitelist)[::prefs::kHomePageIsNewTabPage] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kWebKitDefaultFixedFontSize] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kWebKitDefaultFontSize] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kWebKitMinimumFontSize] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kWebKitFixedFontFamily] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kWebKitSansSerifFontFamily] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kWebKitSerifFontFamily] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kWebKitStandardFontFamily] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kDefaultCharset] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
 #if defined(OS_MACOSX)
   (*s_whitelist)[::prefs::kWebkitTabsToLinks] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #endif
 
   // On startup.
   (*s_whitelist)[::prefs::kRestoreOnStartup] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kURLsToRestoreOnStartup] =
-      settings_private::PrefType::PREF_TYPE_LIST;
+      settings_api::PrefType::PREF_TYPE_LIST;
 
   // Downloads settings.
   (*s_whitelist)[::prefs::kDownloadDefaultDirectory] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kPromptForDownload] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[drive::prefs::kDisableDrive] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Printing settings.
   (*s_whitelist)[::prefs::kLocalDiscoveryNotificationsEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Miscellaneous. TODO(stevenjb): categorize.
   (*s_whitelist)[::prefs::kEnableDoNotTrack] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kEnableEncryptedMedia] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kApplicationLocale] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kNetworkPredictionOptions] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[password_manager::prefs::kCredentialsEnableService] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[password_manager::prefs::kCredentialsEnableAutosignin] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kSafeBrowsingEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kSafeBrowsingExtendedReportingEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kSearchSuggestEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Languages page
+  (*s_whitelist)[spellcheck::prefs::kSpellCheckEnable] =
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[spellcheck::prefs::kSpellCheckDictionaries] =
-      settings_private::PrefType::PREF_TYPE_LIST;
+      settings_api::PrefType::PREF_TYPE_LIST;
+  (*s_whitelist)[spellcheck::prefs::kSpellCheckForcedDictionaries] =
+      settings_api::PrefType::PREF_TYPE_LIST;
   (*s_whitelist)[spellcheck::prefs::kSpellCheckUseSpellingService] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kOfferTranslateEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[translate::TranslatePrefs::kPrefTranslateBlockedLanguages] =
-      settings_private::PrefType::PREF_TYPE_LIST;
+      settings_api::PrefType::PREF_TYPE_LIST;
 #if defined(OS_CHROMEOS)
   (*s_whitelist)[::prefs::kLanguageImeMenuActivated] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #endif
 
   // Search page.
   (*s_whitelist)[DefaultSearchManager::kDefaultSearchProviderDataPrefName] =
-      settings_private::PrefType::PREF_TYPE_DICTIONARY;
+      settings_api::PrefType::PREF_TYPE_DICTIONARY;
 
   // Site Settings prefs.
   (*s_whitelist)[::prefs::kBlockThirdPartyCookies] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kPluginsAlwaysOpenPdfExternally] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kEnableDRM] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Clear browsing data settings.
   (*s_whitelist)[browsing_data::prefs::kDeleteBrowsingHistory] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteBrowsingHistoryBasic] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteDownloadHistory] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteCache] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteCacheBasic] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteCookies] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteCookiesBasic] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeletePasswords] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteFormData] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteSiteSettings] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteHostedAppsData] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteMediaLicenses] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteTimePeriod] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[browsing_data::prefs::kDeleteTimePeriodBasic] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[browsing_data::prefs::kLastClearBrowsingDataTab] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
 
 #if defined(OS_CHROMEOS)
   // Accounts / Users / People.
   (*s_whitelist)[chromeos::kAccountsPrefAllowGuest] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kAccountsPrefSupervisedUsersEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kAccountsPrefShowUserNamesOnSignIn] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kAccountsPrefAllowNewUser] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kAccountsPrefUsers] =
-      settings_private::PrefType::PREF_TYPE_LIST;
+      settings_api::PrefType::PREF_TYPE_LIST;
   (*s_whitelist)[::prefs::kEnableAutoScreenLock] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kEnableQuickUnlockFingerprint] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[proximity_auth::prefs::kEasyUnlockProximityThreshold] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[proximity_auth::prefs::kProximityAuthIsChromeOSLoginEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Accessibility.
   (*s_whitelist)[ash::prefs::kAccessibilitySpokenFeedbackEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityAutoclickEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityAutoclickDelayMs] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityCaretHighlightEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityCursorHighlightEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kShouldAlwaysShowAccessibilityMenu] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityFocusHighlightEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityHighContrastEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityLargeCursorEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityLargeCursorDipSize] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[ash::prefs::kAccessibilityScreenMagnifierEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilitySelectToSpeakEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityStickyKeysEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilitySwitchAccessEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityVirtualKeyboardEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kAccessibilityMonoAudioEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Android Apps.
   (*s_whitelist)[arc::prefs::kArcEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Google Assistant.
   (*s_whitelist)[arc::prefs::kArcVoiceInteractionValuePropAccepted] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[arc::prefs::kVoiceInteractionEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[arc::prefs::kVoiceInteractionContextEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Misc.
   (*s_whitelist)[::prefs::kUse24HourClock] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kLanguagePreferredLanguages] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kTapDraggingEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kStatsReportingPref] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kAttestationForContentProtectionEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[prefs::kRestoreLastLockScreenNote] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Bluetooth & Internet settings.
   (*s_whitelist)[chromeos::kAllowBluetooth] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[proxy_config::prefs::kUseSharedProxies] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kWakeOnWifiDarkConnect] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::chromeos::kSignedDataRoamingEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::ash::prefs::kUserBluetoothAdapterEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Timezone settings.
   (*s_whitelist)[chromeos::kSystemTimezone] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[prefs::kUserTimezone] =
-      settings_private::PrefType::PREF_TYPE_STRING;
-  (*s_whitelist)[prefs::kResolveTimezoneByGeolocationMethod] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_STRING;
+  (*s_whitelist)[settings_private::kResolveTimezoneByGeolocationOnOff] =
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[chromeos::kPerUserTimezoneEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
+  (*s_whitelist)[settings_private::kResolveTimezoneByGeolocationMethodShort] =
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[chromeos::kFineGrainedTimeZoneResolveEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[prefs::kSystemTimezoneAutomaticDetectionPolicy] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
 
   // Ash settings.
   (*s_whitelist)[ash::prefs::kEnableStylusTools] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kLaunchPaletteOnEjectEvent] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kNightLightEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[ash::prefs::kNightLightTemperature] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[ash::prefs::kNightLightScheduleType] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[ash::prefs::kNightLightCustomStartTime] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[ash::prefs::kNightLightCustomEndTime] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
 
   // Input method settings.
   (*s_whitelist)[::prefs::kLanguagePreloadEngines] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
   (*s_whitelist)[::prefs::kLanguageEnabledExtensionImes] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
 
   // Device settings.
   (*s_whitelist)[::prefs::kTapToClickEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kNaturalScroll] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kTouchpadSensitivity] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kPrimaryMouseButtonRight] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kMouseReverseScroll] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kMouseSensitivity] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapSearchKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapControlKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapAltKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapCapsLockKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapBackspaceKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapEscapeKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageRemapDiamondKeyTo] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageSendFunctionKeys] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kLanguageXkbAutoRepeatEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kLanguageXkbAutoRepeatDelay] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageXkbAutoRepeatInterval] =
-      settings_private::PrefType::PREF_TYPE_NUMBER;
+      settings_api::PrefType::PREF_TYPE_NUMBER;
 
   // Multidevice settings.
   (*s_whitelist)[arc::prefs::kSmsConnectEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
 #else
   (*s_whitelist)[::prefs::kAcceptLanguages] =
-      settings_private::PrefType::PREF_TYPE_STRING;
+      settings_api::PrefType::PREF_TYPE_STRING;
 
   // System settings.
   (*s_whitelist)[::prefs::kBackgroundModeEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kHardwareAccelerationModeEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   // Import data
   (*s_whitelist)[::prefs::kImportDialogAutofillFormData] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kImportDialogBookmarks] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kImportDialogHistory] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kImportDialogSavedPasswords] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[::prefs::kImportDialogSearchEngine] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #endif
 
   // Proxy settings.
   (*s_whitelist)[proxy_config::prefs::kProxy] =
-      settings_private::PrefType::PREF_TYPE_DICTIONARY;
+      settings_api::PrefType::PREF_TYPE_DICTIONARY;
 
 #if defined(GOOGLE_CHROME_BUILD)
   (*s_whitelist)[::prefs::kMediaRouterEnableCloudServices] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
   // Media Remoting settings.
   (*s_whitelist)[::prefs::kMediaRouterMediaRemotingEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      settings_api::PrefType::PREF_TYPE_BOOLEAN;
 
   return *s_whitelist;
 }
 
-settings_private::PrefType PrefsUtil::GetWhitelistedPrefType(
+settings_api::PrefType PrefsUtil::GetWhitelistedPrefType(
     const std::string& pref_name) {
   const TypedPrefMap& keys = GetWhitelistedKeys();
   const auto& iter = keys.find(pref_name);
   return iter != keys.end() ? iter->second
-                            : settings_private::PrefType::PREF_TYPE_NONE;
+                            : settings_api::PrefType::PREF_TYPE_NONE;
 }
 
-settings_private::PrefType PrefsUtil::GetType(const std::string& name,
-                                              base::Value::Type type) {
+settings_api::PrefType PrefsUtil::GetType(const std::string& name,
+                                          base::Value::Type type) {
   switch (type) {
     case base::Value::Type::BOOLEAN:
-      return settings_private::PrefType::PREF_TYPE_BOOLEAN;
+      return settings_api::PrefType::PREF_TYPE_BOOLEAN;
     case base::Value::Type::INTEGER:
     case base::Value::Type::DOUBLE:
-      return settings_private::PrefType::PREF_TYPE_NUMBER;
+      return settings_api::PrefType::PREF_TYPE_NUMBER;
     case base::Value::Type::STRING:
-      return IsPrefTypeURL(name) ? settings_private::PrefType::PREF_TYPE_URL
-                                 : settings_private::PrefType::PREF_TYPE_STRING;
+      return IsPrefTypeURL(name) ? settings_api::PrefType::PREF_TYPE_URL
+                                 : settings_api::PrefType::PREF_TYPE_STRING;
     case base::Value::Type::LIST:
-      return settings_private::PrefType::PREF_TYPE_LIST;
+      return settings_api::PrefType::PREF_TYPE_LIST;
     case base::Value::Type::DICTIONARY:
-      return settings_private::PrefType::PREF_TYPE_DICTIONARY;
+      return settings_api::PrefType::PREF_TYPE_DICTIONARY;
     default:
-      return settings_private::PrefType::PREF_TYPE_NONE;
+      return settings_api::PrefType::PREF_TYPE_NONE;
   }
 }
 
-std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetCrosSettingsPref(
+std::unique_ptr<settings_api::PrefObject> PrefsUtil::GetCrosSettingsPref(
     const std::string& name) {
-  std::unique_ptr<settings_private::PrefObject> pref_object(
-      new settings_private::PrefObject());
+  std::unique_ptr<settings_api::PrefObject> pref_object(
+      new settings_api::PrefObject());
 
 #if defined(OS_CHROMEOS)
   const base::Value* value = CrosSettings::Get()->GetPref(name);
@@ -489,37 +497,32 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetCrosSettingsPref(
   return pref_object;
 }
 
-std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
+std::unique_ptr<settings_api::PrefObject> PrefsUtil::GetPref(
     const std::string& name) {
-  if (GetWhitelistedPrefType(name) ==
-      settings_private::PrefType::PREF_TYPE_NONE) {
+  if (GetWhitelistedPrefType(name) == settings_api::PrefType::PREF_TYPE_NONE) {
     return nullptr;
   }
 
+  settings_private::GeneratedPrefs* generated_prefs =
+      settings_private::GeneratedPrefsFactory::GetForBrowserContext(profile_);
+
   const PrefService::Preference* pref = nullptr;
-  std::unique_ptr<settings_private::PrefObject> pref_object;
+  std::unique_ptr<settings_api::PrefObject> pref_object;
   if (IsCrosSetting(name)) {
     pref_object = GetCrosSettingsPref(name);
     if (!pref_object)
       return nullptr;
+  } else if (generated_prefs && generated_prefs->HasPref(name)) {
+    return generated_prefs->GetPref(name);
   } else {
     PrefService* pref_service = FindServiceForPref(name);
     pref = pref_service->FindPreference(name);
     if (!pref)
       return nullptr;
-    pref_object.reset(new settings_private::PrefObject());
+    pref_object.reset(new settings_api::PrefObject());
     pref_object->key = pref->name();
     pref_object->type = GetType(name, pref->GetType());
-#if defined(OS_CHROMEOS)
-    if (name == prefs::kResolveTimezoneByGeolocationMethod) {
-      pref_object->value.reset(new base::Value(
-          static_cast<int>(chromeos::system::TimeZoneResolverManager::
-                               GetEffectiveUserTimeZoneResolveMethod(
-                                   pref_service, true /* check_policy */))));
-    }
-#endif
-    if (!pref_object->value)
-      pref_object->value.reset(pref->GetValue()->DeepCopy());
+    pref_object->value.reset(pref->GetValue()->DeepCopy());
   }
 
 #if defined(OS_CHROMEOS)
@@ -532,17 +535,15 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
     // Enterprise managed prefs are treated the same as device policy restricted
     // prefs in the UI.
     pref_object->controlled_by =
-        settings_private::ControlledBy::CONTROLLED_BY_DEVICE_POLICY;
-    pref_object->enforcement =
-        settings_private::Enforcement::ENFORCEMENT_ENFORCED;
+        settings_api::ControlledBy::CONTROLLED_BY_DEVICE_POLICY;
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
     return pref_object;
   }
 
   if (IsPrefPrimaryUserControlled(name)) {
     pref_object->controlled_by =
-        settings_private::ControlledBy::CONTROLLED_BY_PRIMARY_USER;
-    pref_object->enforcement =
-        settings_private::Enforcement::ENFORCEMENT_ENFORCED;
+        settings_api::ControlledBy::CONTROLLED_BY_PRIMARY_USER;
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
     pref_object->controlled_by_name.reset(
         new std::string(user_manager::UserManager::Get()
                             ->GetPrimaryUser()
@@ -554,9 +555,8 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
 
   if (pref && pref->IsManaged()) {
     pref_object->controlled_by =
-        settings_private::ControlledBy::CONTROLLED_BY_USER_POLICY;
-    pref_object->enforcement =
-        settings_private::Enforcement::ENFORCEMENT_ENFORCED;
+        settings_api::ControlledBy::CONTROLLED_BY_USER_POLICY;
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
     return pref_object;
   }
 
@@ -566,9 +566,9 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
   const base::Value* recommended = pref ? pref->GetRecommendedValue() : nullptr;
   if (recommended) {
     pref_object->controlled_by =
-        settings_private::ControlledBy::CONTROLLED_BY_USER_POLICY;
+        settings_api::ControlledBy::CONTROLLED_BY_USER_POLICY;
     pref_object->enforcement =
-        settings_private::Enforcement::ENFORCEMENT_RECOMMENDED;
+        settings_api::Enforcement::ENFORCEMENT_RECOMMENDED;
     pref_object->recommended_value.reset(recommended->DeepCopy());
     return pref_object;
   }
@@ -580,9 +580,8 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
     // situations apply, either badge is potentially relevant, so the order
     // is somewhat arbitrary).
     pref_object->controlled_by =
-        settings_private::ControlledBy::CONTROLLED_BY_OWNER;
-    pref_object->enforcement =
-        settings_private::Enforcement::ENFORCEMENT_ENFORCED;
+        settings_api::ControlledBy::CONTROLLED_BY_OWNER;
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
     pref_object->controlled_by_name.reset(new std::string(
         user_manager::UserManager::Get()->GetOwnerAccountId().GetUserEmail()));
     return pref_object;
@@ -593,9 +592,8 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
 
   if (extension) {
     pref_object->controlled_by =
-        settings_private::ControlledBy::CONTROLLED_BY_EXTENSION;
-    pref_object->enforcement =
-        settings_private::Enforcement::ENFORCEMENT_ENFORCED;
+        settings_api::ControlledBy::CONTROLLED_BY_EXTENSION;
+    pref_object->enforcement = settings_api::Enforcement::ENFORCEMENT_ENFORCED;
     pref_object->extension_id.reset(new std::string(extension->id()));
     pref_object->controlled_by_name.reset(new std::string(extension->name()));
     bool can_be_disabled = !ExtensionSystem::Get(profile_)->management_policy()
@@ -609,24 +607,29 @@ std::unique_ptr<settings_private::PrefObject> PrefsUtil::GetPref(
   return pref_object;
 }
 
-PrefsUtil::SetPrefResult PrefsUtil::SetPref(const std::string& pref_name,
-                                            const base::Value* value) {
+settings_private::SetPrefResult PrefsUtil::SetPref(const std::string& pref_name,
+                                                   const base::Value* value) {
   if (GetWhitelistedPrefType(pref_name) ==
-      settings_private::PrefType::PREF_TYPE_NONE) {
-    return PREF_NOT_FOUND;
+      settings_api::PrefType::PREF_TYPE_NONE) {
+    return settings_private::SetPrefResult::PREF_NOT_FOUND;
   }
 
   if (IsCrosSetting(pref_name))
     return SetCrosSettingsPref(pref_name, value);
 
+  settings_private::GeneratedPrefs* generated_prefs =
+      settings_private::GeneratedPrefsFactory::GetForBrowserContext(profile_);
+  if (generated_prefs && generated_prefs->HasPref(pref_name))
+    return generated_prefs->SetPref(pref_name, value);
+
   PrefService* pref_service = FindServiceForPref(pref_name);
 
   if (!IsPrefUserModifiable(pref_name))
-    return PREF_NOT_MODIFIABLE;
+    return settings_private::SetPrefResult::PREF_NOT_MODIFIABLE;
 
   const PrefService::Preference* pref = pref_service->FindPreference(pref_name);
   if (!pref)
-    return PREF_NOT_FOUND;
+    return settings_private::SetPrefResult::PREF_NOT_FOUND;
 
   switch (pref->GetType()) {
     case base::Value::Type::BOOLEAN:
@@ -639,27 +642,15 @@ PrefsUtil::SetPrefResult PrefsUtil::SetPref(const std::string& pref_name,
       // In JS all numbers are doubles.
       double double_value;
       if (!value->GetAsDouble(&double_value))
-        return PREF_TYPE_MISMATCH;
+        return settings_private::SetPrefResult::PREF_TYPE_MISMATCH;
 
-      bool value_set = false;
-#if defined(OS_CHROMEOS)
-      if (pref_name == ::prefs::kResolveTimezoneByGeolocationMethod) {
-        pref_service->SetInteger(
-            pref_name,
-            static_cast<int>(chromeos::system::TimeZoneResolverManager::
-                                 TimeZoneResolveMethodFromInt(
-                                     static_cast<int>(double_value))));
-        value_set = true;
-      }
-#endif
-      if (!value_set)
-        pref_service->SetInteger(pref_name, static_cast<int>(double_value));
+      pref_service->SetInteger(pref_name, static_cast<int>(double_value));
       break;
     }
     case base::Value::Type::STRING: {
       std::string string_value;
       if (!value->GetAsString(&string_value))
-        return PREF_TYPE_MISMATCH;
+        return settings_private::SetPrefResult::PREF_TYPE_MISMATCH;
 
       if (IsPrefTypeURL(pref_name)) {
         GURL fixed = url_formatter::FixupURL(string_value, std::string());
@@ -673,16 +664,17 @@ PrefsUtil::SetPrefResult PrefsUtil::SetPref(const std::string& pref_name,
       break;
     }
     default:
-      return PREF_TYPE_UNSUPPORTED;
+      return settings_private::SetPrefResult::PREF_TYPE_UNSUPPORTED;
   }
 
   // TODO(orenb): Process setting metrics here and in the CrOS setting method
   // too (like "ProcessUserMetric" in CoreOptionsHandler).
-  return SUCCESS;
+  return settings_private::SetPrefResult::SUCCESS;
 }
 
-PrefsUtil::SetPrefResult PrefsUtil::SetCrosSettingsPref(
-    const std::string& pref_name, const base::Value* value) {
+settings_private::SetPrefResult PrefsUtil::SetCrosSettingsPref(
+    const std::string& pref_name,
+    const base::Value* value) {
 #if defined(OS_CHROMEOS)
   chromeos::OwnerSettingsServiceChromeOS* service =
       chromeos::OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
@@ -691,14 +683,14 @@ PrefsUtil::SetPrefResult PrefsUtil::SetCrosSettingsPref(
   // Check if setting requires owner.
   if (service && service->HandlesSetting(pref_name)) {
     if (service->Set(pref_name, *value))
-      return SUCCESS;
-    return PREF_NOT_MODIFIABLE;
+      return settings_private::SetPrefResult::SUCCESS;
+    return settings_private::SetPrefResult::PREF_NOT_MODIFIABLE;
   }
 
   CrosSettings::Get()->Set(pref_name, *value);
-  return SUCCESS;
+  return settings_private::SetPrefResult::SUCCESS;
 #else
-  return PREF_NOT_FOUND;
+  return settings_private::SetPrefResult::PREF_NOT_FOUND;
 #endif
 }
 
@@ -742,7 +734,7 @@ bool PrefsUtil::RemoveFromListCrosSetting(const std::string& pref_name,
 
 bool PrefsUtil::IsPrefTypeURL(const std::string& pref_name) {
   return GetWhitelistedPrefType(pref_name) ==
-         settings_private::PrefType::PREF_TYPE_URL;
+         settings_api::PrefType::PREF_TYPE_URL;
 }
 
 #if defined(OS_CHROMEOS)
@@ -754,8 +746,7 @@ bool PrefsUtil::IsPrefEnterpriseManaged(const std::string& pref_name) {
   if (IsPrivilegedCrosSetting(pref_name))
     return true;
   if (pref_name == chromeos::kSystemTimezone ||
-      pref_name == prefs::kUserTimezone ||
-      pref_name == prefs::kResolveTimezoneByGeolocationMethod) {
+      pref_name == prefs::kUserTimezone) {
     return chromeos::system::IsTimezonePrefsManaged(pref_name);
   }
   return false;
@@ -778,7 +769,6 @@ bool PrefsUtil::IsPrefPrimaryUserControlled(const std::string& pref_name) {
   // chromeos::kSystemTimezone is read-only, but for the non-primary users
   // it should have "primary user controlled" attribute.
   if (pref_name == prefs::kWakeOnWifiDarkConnect ||
-      pref_name == prefs::kResolveTimezoneByGeolocationMethod ||
       pref_name == prefs::kUserTimezone ||
       pref_name == chromeos::kSystemTimezone) {
     user_manager::UserManager* user_manager = user_manager::UserManager::Get();
@@ -857,7 +847,7 @@ bool PrefsUtil::IsCrosSetting(const std::string& pref_name) {
 }
 
 const Extension* PrefsUtil::GetExtensionControllingPref(
-    const settings_private::PrefObject& pref_object) {
+    const settings_api::PrefObject& pref_object) {
   // Look for specific prefs that might be extension controlled. This generally
   // corresponds with some indiciator that should be shown in the settings UI.
   if (pref_object.key == ::prefs::kHomePage)
diff --git a/chromium/chrome/browser/extensions/api/settings_private/prefs_util.h b/chromium/chrome/browser/extensions/api/settings_private/prefs_util.h
index 8695af459ca..a67fb4f5787 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/prefs_util.h
+++ b/chromium/chrome/browser/extensions/api/settings_private/prefs_util.h
@@ -11,6 +11,7 @@
 
 #include "base/macros.h"
 #include "build/build_config.h"
+#include "chrome/browser/extensions/api/settings_private/prefs_util_enums.h"
 #include "chrome/common/extensions/api/settings_private.h"
 
 class PrefService;
@@ -22,15 +23,6 @@ class Extension;
 class PrefsUtil {
 
  public:
-  // Success or error statuses from calling SetPref.
-  enum SetPrefResult {
-    SUCCESS,
-    PREF_NOT_MODIFIABLE,
-    PREF_NOT_FOUND,
-    PREF_TYPE_MISMATCH,
-    PREF_TYPE_UNSUPPORTED
-  };
-
   // TODO(dbeam): why is the key a std::string rather than const char*?
   using TypedPrefMap = std::map<std::string, api::settings_private::PrefType>;
 
@@ -53,8 +45,8 @@ class PrefsUtil {
       const std::string& name);
 
   // Sets the pref with the given name and value in the proper PrefService.
-  virtual SetPrefResult SetPref(const std::string& name,
-                                const base::Value* value);
+  virtual settings_private::SetPrefResult SetPref(const std::string& name,
+                                                  const base::Value* value);
 
   // Appends the given |value| to the list setting specified by the path in
   // |pref_name|.
@@ -105,8 +97,8 @@ class PrefsUtil {
   std::unique_ptr<api::settings_private::PrefObject> GetCrosSettingsPref(
       const std::string& name);
 
-  SetPrefResult SetCrosSettingsPref(const std::string& name,
-                                    const base::Value* value);
+  settings_private::SetPrefResult SetCrosSettingsPref(const std::string& name,
+                                                      const base::Value* value);
 
  private:
   const Extension* GetExtensionControllingPref(
diff --git a/chromium/chrome/browser/extensions/api/settings_private/prefs_util_enums.h b/chromium/chrome/browser/extensions/api/settings_private/prefs_util_enums.h
new file mode 100644
index 00000000000..eeea03873ae
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/settings_private/prefs_util_enums.h
@@ -0,0 +1,23 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_PREFS_UTIL_ENUMS_H_
+#define CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_PREFS_UTIL_ENUMS_H_
+
+namespace extensions {
+namespace settings_private {
+
+// Success or error statuses from calling PrefsUtil::SetPref.
+enum class SetPrefResult {
+  SUCCESS,
+  PREF_NOT_MODIFIABLE,
+  PREF_NOT_FOUND,
+  PREF_TYPE_MISMATCH,
+  PREF_TYPE_UNSUPPORTED
+};
+
+}  // namespace settings_private
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_SETTINGS_PRIVATE_PREFS_UTIL_ENUMS_H_
diff --git a/chromium/chrome/browser/extensions/api/settings_private/settings_private_api.cc b/chromium/chrome/browser/extensions/api/settings_private/settings_private_api.cc
index 38f4d8fdcf1..4898ddb897a 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/settings_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/settings_private/settings_private_api.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/extensions/api/settings_private/settings_private_api.h"
 
+#include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/settings_private/settings_private_delegate.h"
 #include "chrome/browser/extensions/api/settings_private/settings_private_delegate_factory.h"
@@ -40,25 +40,25 @@ ExtensionFunction::ResponseAction SettingsPrivateSetPrefFunction::Run() {
   if (delegate == nullptr)
     return RespondNow(Error(kDelegateIsNull));
 
-  PrefsUtil::SetPrefResult result =
+  settings_private::SetPrefResult result =
       delegate->SetPref(parameters->name, parameters->value.get());
   switch (result) {
-    case PrefsUtil::SUCCESS:
-      return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
-    case PrefsUtil::PREF_NOT_MODIFIABLE:
+    case settings_private::SetPrefResult::SUCCESS:
+      return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
+    case settings_private::SetPrefResult::PREF_NOT_MODIFIABLE:
       // Not an error, but return false to indicate setting the pref failed.
-      return RespondNow(OneArgument(base::MakeUnique<base::Value>(false)));
-    case PrefsUtil::PREF_NOT_FOUND:
+      return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
+    case settings_private::SetPrefResult::PREF_NOT_FOUND:
       return RespondNow(Error("Pref not found: *", parameters->name));
-    case PrefsUtil::PREF_TYPE_MISMATCH:
+    case settings_private::SetPrefResult::PREF_TYPE_MISMATCH:
       return RespondNow(Error("Incorrect type used for value of pref *",
                               parameters->name));
-    case PrefsUtil::PREF_TYPE_UNSUPPORTED:
+    case settings_private::SetPrefResult::PREF_TYPE_UNSUPPORTED:
       return RespondNow(Error("Unsupported type used for value of pref *",
                               parameters->name));
   }
   NOTREACHED();
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(false)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(false)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -141,7 +141,7 @@ ExtensionFunction::ResponseAction
     return RespondNow(Error(kDelegateIsNull));
 
   delegate->SetDefaultZoom(parameters->zoom);
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(true)));
+  return RespondNow(OneArgument(std::make_unique<base::Value>(true)));
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.cc b/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.cc
index 0ad0716d3d4..adf858f84b0 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.cc
+++ b/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.cc
@@ -6,7 +6,6 @@
 
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
@@ -22,8 +21,6 @@
 
 namespace extensions {
 
-namespace settings_private = api::settings_private;
-
 SettingsPrivateDelegate::SettingsPrivateDelegate(Profile* profile)
     : profile_(profile) {
   prefs_util_.reset(new PrefsUtil(profile));
@@ -37,7 +34,7 @@ std::unique_ptr<base::Value> SettingsPrivateDelegate::GetPref(
   std::unique_ptr<api::settings_private::PrefObject> pref =
       prefs_util_->GetPref(name);
   if (!pref)
-    return base::MakeUnique<base::Value>();
+    return std::make_unique<base::Value>();
   return pref->ToValue();
 }
 
@@ -54,8 +51,9 @@ std::unique_ptr<base::Value> SettingsPrivateDelegate::GetAllPrefs() {
   return std::move(prefs);
 }
 
-PrefsUtil::SetPrefResult SettingsPrivateDelegate::SetPref(
-    const std::string& pref_name, const base::Value* value) {
+settings_private::SetPrefResult SettingsPrivateDelegate::SetPref(
+    const std::string& pref_name,
+    const base::Value* value) {
   return prefs_util_->SetPref(pref_name, value);
 }
 
@@ -66,11 +64,11 @@ std::unique_ptr<base::Value> SettingsPrivateDelegate::GetDefaultZoom() {
   return value;
 }
 
-PrefsUtil::SetPrefResult SettingsPrivateDelegate::SetDefaultZoom(
+settings_private::SetPrefResult SettingsPrivateDelegate::SetDefaultZoom(
     double zoom) {
   double zoom_factor = content::ZoomFactorToZoomLevel(zoom);
   profile_->GetZoomLevelPrefs()->SetDefaultZoomLevelPref(zoom_factor);
-  return PrefsUtil::SetPrefResult::SUCCESS;
+  return settings_private::SetPrefResult::SUCCESS;
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.h b/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.h
index 752c2f005e1..e2d07ca2d67 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.h
+++ b/chromium/chrome/browser/extensions/api/settings_private/settings_private_delegate.h
@@ -35,8 +35,8 @@ class SettingsPrivateDelegate : public KeyedService {
   ~SettingsPrivateDelegate() override;
 
   // Sets the pref with the given name and value in the proper PrefService.
-  virtual PrefsUtil::SetPrefResult SetPref(
-      const std::string& name, const base::Value* value);
+  virtual settings_private::SetPrefResult SetPref(const std::string& name,
+                                                  const base::Value* value);
 
   // Gets the value of the pref with the given |name|.
   virtual std::unique_ptr<base::Value> GetPref(const std::string& name);
@@ -48,7 +48,7 @@ class SettingsPrivateDelegate : public KeyedService {
   virtual std::unique_ptr<base::Value> GetDefaultZoom();
 
   // Sets the pref.
-  virtual PrefsUtil::SetPrefResult SetDefaultZoom(double zoom);
+  virtual settings_private::SetPrefResult SetDefaultZoom(double zoom);
 
  protected:
   Profile* profile_;  // weak; not owned by us
diff --git a/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.cc b/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.cc
index d68940e8467..c6804a179b1 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.cc
+++ b/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.cc
@@ -12,6 +12,8 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/settings_private/generated_prefs.h"
+#include "chrome/browser/extensions/api/settings_private/generated_prefs_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/settings_private.h"
 #include "components/prefs/pref_service.h"
@@ -43,6 +45,11 @@ SettingsPrivateEventRouter::~SettingsPrivateEventRouter() {
   DCHECK(!listening_);
 }
 
+void SettingsPrivateEventRouter::OnGeneratedPrefChanged(
+    const std::string& pref_name) {
+  OnPreferenceChanged(pref_name);
+}
+
 void SettingsPrivateEventRouter::Shutdown() {
   // Unregister with the event router. We first check and see if there *is* an
   // event router, because some unit tests try to shutdown all context services,
@@ -54,8 +61,12 @@ void SettingsPrivateEventRouter::Shutdown() {
   if (listening_) {
     cros_settings_subscription_map_.clear();
     const PrefsUtil::TypedPrefMap& keys = prefs_util_->GetWhitelistedKeys();
+    settings_private::GeneratedPrefs* generated_prefs =
+        settings_private::GeneratedPrefsFactory::GetForBrowserContext(context_);
     for (const auto& it : keys) {
-      if (!prefs_util_->IsCrosSetting(it.first))
+      if (generated_prefs && generated_prefs->HasPref(it.first))
+        generated_prefs->RemoveObserver(it.first, this);
+      else if (!prefs_util_->IsCrosSetting(it.first))
         FindRegistrarForPref(it.first)->Remove(it.first);
     }
   }
@@ -89,6 +100,8 @@ void SettingsPrivateEventRouter::StartOrStopListeningForPrefsChanges() {
   bool should_listen = event_router->HasEventListener(
       api::settings_private::OnPrefsChanged::kEventName);
 
+  settings_private::GeneratedPrefs* generated_prefs =
+      settings_private::GeneratedPrefsFactory::GetForBrowserContext(context_);
   if (should_listen && !listening_) {
     const PrefsUtil::TypedPrefMap& keys = prefs_util_->GetWhitelistedKeys();
     for (const auto& it : keys) {
@@ -103,6 +116,8 @@ void SettingsPrivateEventRouter::StartOrStopListeningForPrefsChanges() {
         cros_settings_subscription_map_.insert(
             make_pair(pref_name, std::move(subscription)));
 #endif
+      } else if (generated_prefs && generated_prefs->HasPref(pref_name)) {
+        generated_prefs->AddObserver(pref_name, this);
       } else {
         FindRegistrarForPref(it.first)
             ->Add(pref_name,
@@ -115,6 +130,8 @@ void SettingsPrivateEventRouter::StartOrStopListeningForPrefsChanges() {
     for (const auto& it : keys) {
       if (prefs_util_->IsCrosSetting(it.first))
         cros_settings_subscription_map_.erase(it.first);
+      else if (generated_prefs && generated_prefs->HasPref(it.first))
+        generated_prefs->RemoveObserver(it.first, this);
       else
         FindRegistrarForPref(it.first)->Remove(it.first);
     }
diff --git a/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.h b/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.h
index 3b79001d779..4d28143ee7b 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.h
+++ b/chromium/chrome/browser/extensions/api/settings_private/settings_private_event_router.h
@@ -9,6 +9,7 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/extensions/api/settings_private/generated_pref.h"
 #include "chrome/browser/extensions/api/settings_private/prefs_util.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/prefs/pref_change_registrar.h"
@@ -30,13 +31,18 @@ namespace extensions {
 // This is an event router that will observe listeners to pref changes on the
 // appropriate pref service(s) and notify listeners on the JavaScript
 // settingsPrivate API.
-class SettingsPrivateEventRouter : public KeyedService,
-                                   public EventRouter::Observer {
+class SettingsPrivateEventRouter
+    : public KeyedService,
+      public EventRouter::Observer,
+      public settings_private::GeneratedPref::Observer {
  public:
   static SettingsPrivateEventRouter* Create(
       content::BrowserContext* browser_context);
   ~SettingsPrivateEventRouter() override;
 
+  // settings_private::GeneratedPref::Observer implementation.
+  void OnGeneratedPrefChanged(const std::string& pref_name) override;
+
  protected:
   explicit SettingsPrivateEventRouter(content::BrowserContext* context);
 
diff --git a/chromium/chrome/browser/extensions/api/signed_in_devices/id_mapping_helper_unittest.cc b/chromium/chrome/browser/extensions/api/signed_in_devices/id_mapping_helper_unittest.cc
index 83f7d3ad682..6f296a9a38f 100644
--- a/chromium/chrome/browser/extensions/api/signed_in_devices/id_mapping_helper_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/signed_in_devices/id_mapping_helper_unittest.cc
@@ -8,7 +8,6 @@
 #include <string>
 
 #include "base/guid.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/sync/device_info/device_info.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -32,11 +31,11 @@ bool VerifyDictionary(
 TEST(IdMappingHelperTest, SetIdsForDevices) {
   std::vector<std::unique_ptr<DeviceInfo>> devices;
 
-  devices.push_back(base::MakeUnique<DeviceInfo>(
+  devices.push_back(std::make_unique<DeviceInfo>(
       base::GenerateGUID(), "abc Device", "XYZ v1", "XYZ SyncAgent v1",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id1"));
 
-  devices.push_back(base::MakeUnique<DeviceInfo>(
+  devices.push_back(std::make_unique<DeviceInfo>(
       base::GenerateGUID(), "def Device", "XYZ v1", "XYZ SyncAgent v1",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id2"));
 
@@ -53,7 +52,7 @@ TEST(IdMappingHelperTest, SetIdsForDevices) {
   EXPECT_NE(public_id1, public_id2);
 
   // Now add a third device.
-  devices.push_back(base::MakeUnique<DeviceInfo>(
+  devices.push_back(std::make_unique<DeviceInfo>(
       base::GenerateGUID(), "ghi Device", "XYZ v1", "XYZ SyncAgent v1",
       sync_pb::SyncEnums_DeviceType_TYPE_LINUX, "device_id3"));
 
diff --git a/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc b/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc
index 05c9e3b33ca..32d5acdee69 100644
--- a/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc
@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "base/guid.h"
-#include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
@@ -45,7 +44,7 @@ class MockDeviceInfoTracker : public DeviceInfoTracker {
 
   static std::unique_ptr<DeviceInfo> CloneDeviceInfo(
       const DeviceInfo& device_info) {
-    return base::MakeUnique<DeviceInfo>(
+    return std::make_unique<DeviceInfo>(
         device_info.guid(), device_info.client_name(),
         device_info.chrome_version(), device_info.sync_user_agent(),
         device_info.device_type(), device_info.signin_scoped_device_id());
@@ -150,7 +149,7 @@ class ProfileSyncServiceMockForExtensionTests
 
 std::unique_ptr<KeyedService> CreateProfileSyncServiceMock(
     content::BrowserContext* context) {
-  return base::MakeUnique<ProfileSyncServiceMockForExtensionTests>(
+  return std::make_unique<ProfileSyncServiceMockForExtensionTests>(
       Profile::FromBrowserContext(context));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_manager.cc b/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_manager.cc
index cbca1fbb814..75a6bba54fb 100644
--- a/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_manager.cc
+++ b/chromium/chrome/browser/extensions/api/signed_in_devices/signed_in_devices_manager.cc
@@ -10,7 +10,6 @@
 #include <vector>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ -75,7 +74,7 @@ void SignedInDevicesChangeObserver::OnDeviceInfoChange() {
 
   std::unique_ptr<base::ListValue> result =
       api::signed_in_devices::OnDeviceInfoChange::Create(args);
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::SIGNED_IN_DEVICES_ON_DEVICE_INFO_CHANGE,
       api::signed_in_devices::OnDeviceInfoChange::kEventName, std::move(result),
       profile_);
@@ -132,7 +131,7 @@ void SignedInDevicesManager::OnListenerAdded(
     }
   }
 
-  change_observers_.push_back(base::MakeUnique<SignedInDevicesChangeObserver>(
+  change_observers_.push_back(std::make_unique<SignedInDevicesChangeObserver>(
       details.extension_id, profile_));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/socket/combined_socket_unittest.cc b/chromium/chrome/browser/extensions/api/socket/combined_socket_unittest.cc
index 14de64940ae..6feb6fe9361 100644
--- a/chromium/chrome/browser/extensions/api/socket/combined_socket_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/socket/combined_socket_unittest.cc
@@ -4,7 +4,6 @@
 
 #include <memory>
 
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/api/socket/mock_tcp_client_socket.h"
 #include "extensions/browser/api/socket/socket.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
@@ -24,14 +23,14 @@ std::unique_ptr<T> CreateTestSocket(
 template <>
 std::unique_ptr<TCPSocket> CreateTestSocket(
     std::unique_ptr<MockTCPClientSocket> stream) {
-  return base::MakeUnique<TCPSocket>(std::move(stream), "fake id",
+  return std::make_unique<TCPSocket>(std::move(stream), "fake id",
                                      true /* is_connected */);
 }
 
 template <>
 std::unique_ptr<TLSSocket> CreateTestSocket(
     std::unique_ptr<MockTCPClientSocket> stream) {
-  return base::MakeUnique<TLSSocket>(std::move(stream), "fake id");
+  return std::make_unique<TLSSocket>(std::move(stream), "fake id");
 }
 
 class CombinedSocketTest : public testing::Test {
diff --git a/chromium/chrome/browser/extensions/api/socket/mock_tcp_client_socket.h b/chromium/chrome/browser/extensions/api/socket/mock_tcp_client_socket.h
index 0db73de4cd9..9dd6af53b29 100644
--- a/chromium/chrome/browser/extensions/api/socket/mock_tcp_client_socket.h
+++ b/chromium/chrome/browser/extensions/api/socket/mock_tcp_client_socket.h
@@ -8,6 +8,7 @@
 #include "net/log/net_log_source.h"
 #include "net/log/net_log_with_source.h"
 #include "net/socket/tcp_client_socket.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace extensions {
@@ -18,7 +19,11 @@ class MockTCPClientSocket : public net::TCPClientSocket {
   virtual ~MockTCPClientSocket();
 
   MOCK_METHOD3(Read, int(net::IOBuffer*, int, const net::CompletionCallback&));
-  MOCK_METHOD3(Write, int(net::IOBuffer*, int, const net::CompletionCallback&));
+  MOCK_METHOD4(Write,
+               int(net::IOBuffer*,
+                   int,
+                   const net::CompletionCallback&,
+                   const net::NetworkTrafficAnnotationTag&));
   MOCK_METHOD1(SetReceiveBufferSize, int(int32_t));
   MOCK_METHOD1(SetSendBufferSize, int(int32_t));
   MOCK_METHOD1(Connect, int(const net::CompletionCallback&));
diff --git a/chromium/chrome/browser/extensions/api/socket/socket_api_unittest.cc b/chromium/chrome/browser/extensions/api/socket/socket_api_unittest.cc
index 34e18a136c8..11ac53ebdf4 100644
--- a/chromium/chrome/browser/extensions/api/socket/socket_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/socket/socket_api_unittest.cc
@@ -4,7 +4,6 @@
 
 #include <memory>
 
-#include "base/memory/ptr_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process_impl.h"
@@ -22,7 +21,7 @@ namespace extensions {
 
 std::unique_ptr<KeyedService> ApiResourceManagerTestFactory(
     content::BrowserContext* context) {
-  return base::MakeUnique<ApiResourceManager<Socket>>(context);
+  return std::make_unique<ApiResourceManager<Socket>>(context);
 }
 
 class SocketUnitTest : public ExtensionApiUnittest {
diff --git a/chromium/chrome/browser/extensions/api/socket/tcp_socket_unittest.cc b/chromium/chrome/browser/extensions/api/socket/tcp_socket_unittest.cc
index ac8a6fda363..902970df9ff 100644
--- a/chromium/chrome/browser/extensions/api/socket/tcp_socket_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/socket/tcp_socket_unittest.cc
@@ -14,6 +14,7 @@
 #include "net/log/net_log_source.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_server_socket.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
@@ -30,8 +31,11 @@ class MockTCPSocket : public net::TCPClientSocket {
 
   MOCK_METHOD3(Read, int(net::IOBuffer* buf, int buf_len,
                          const net::CompletionCallback& callback));
-  MOCK_METHOD3(Write, int(net::IOBuffer* buf, int buf_len,
-                          const net::CompletionCallback& callback));
+  MOCK_METHOD4(Write,
+               int(net::IOBuffer* buf,
+                   int buf_len,
+                   const net::CompletionCallback& callback,
+                   const net::NetworkTrafficAnnotationTag&));
   MOCK_METHOD2(SetKeepAlive, bool(bool enable, int delay));
   MOCK_METHOD1(SetNoDelay, bool(bool no_delay));
   bool IsConnected() const override {
@@ -100,10 +104,9 @@ TEST(SocketTest, TestTCPSocketWrite) {
   CompleteHandler handler;
 
   net::CompletionCallback callback;
-  EXPECT_CALL(*tcp_client_socket, Write(_, _, _))
+  EXPECT_CALL(*tcp_client_socket, Write(_, _, _, _))
       .Times(2)
-      .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback),
-                                     Return(128)));
+      .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback), Return(128)));
   EXPECT_CALL(handler, OnComplete(_))
       .Times(1);
 
@@ -123,10 +126,10 @@ TEST(SocketTest, TestTCPSocketBlockedWrite) {
   CompleteHandler handler;
 
   net::CompletionCallback callback;
-  EXPECT_CALL(*tcp_client_socket, Write(_, _, _))
+  EXPECT_CALL(*tcp_client_socket, Write(_, _, _, _))
       .Times(2)
-      .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback),
-                                     Return(net::ERR_IO_PENDING)));
+      .WillRepeatedly(
+          testing::DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
 
   std::unique_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
       std::move(tcp_client_socket), FAKE_ID, true));
@@ -150,10 +153,10 @@ TEST(SocketTest, TestTCPSocketBlockedWriteReentry) {
   CompleteHandler handlers[5];
 
   net::CompletionCallback callback;
-  EXPECT_CALL(*tcp_client_socket, Write(_, _, _))
+  EXPECT_CALL(*tcp_client_socket, Write(_, _, _, _))
       .Times(5)
-      .WillRepeatedly(testing::DoAll(SaveArg<2>(&callback),
-                                     Return(net::ERR_IO_PENDING)));
+      .WillRepeatedly(
+          testing::DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
 
   std::unique_ptr<TCPSocket> socket(TCPSocket::CreateSocketForTesting(
       std::move(tcp_client_socket), FAKE_ID, true));
diff --git a/chromium/chrome/browser/extensions/api/socket/tls_socket_unittest.cc b/chromium/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
index e882c99a1f6..d89d7300d9b 100644
--- a/chromium/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
@@ -20,8 +20,10 @@
 #include "net/log/net_log_source.h"
 #include "net/log/net_log_with_source.h"
 #include "net/socket/next_proto.h"
+#include "net/socket/socket_tag.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
@@ -43,10 +45,11 @@ class MockSSLClientSocket : public net::SSLClientSocket {
                int(net::IOBuffer* buf,
                    int buf_len,
                    const net::CompletionCallback& callback));
-  MOCK_METHOD3(Write,
+  MOCK_METHOD4(Write,
                int(net::IOBuffer* buf,
                    int buf_len,
-                   const net::CompletionCallback& callback));
+                   const net::CompletionCallback& callback,
+                   const net::NetworkTrafficAnnotationTag&));
   MOCK_METHOD1(SetReceiveBufferSize, int(int32_t));
   MOCK_METHOD1(SetSendBufferSize, int(int32_t));
   MOCK_METHOD1(Connect, int(const CompletionCallback&));
@@ -65,6 +68,7 @@ class MockSSLClientSocket : public net::SSLClientSocket {
   MOCK_METHOD0(ClearConnectionAttempts, void());
   MOCK_METHOD1(AddConnectionAttempts, void(const net::ConnectionAttempts&));
   MOCK_CONST_METHOD0(GetTotalReceivedBytes, int64_t());
+  MOCK_METHOD1(ApplySocketTag, void(const net::SocketTag&));
   MOCK_METHOD5(ExportKeyingMaterial,
                int(const StringPiece&,
                    bool,
@@ -95,10 +99,11 @@ class MockTCPSocket : public net::TCPClientSocket {
                int(net::IOBuffer* buf,
                    int buf_len,
                    const net::CompletionCallback& callback));
-  MOCK_METHOD3(Write,
+  MOCK_METHOD4(Write,
                int(net::IOBuffer* buf,
                    int buf_len,
-                   const net::CompletionCallback& callback));
+                   const net::CompletionCallback& callback,
+                   const net::NetworkTrafficAnnotationTag&));
   MOCK_METHOD2(SetKeepAlive, bool(bool enable, int delay));
   MOCK_METHOD1(SetNoDelay, bool(bool no_delay));
 
@@ -167,8 +172,9 @@ TEST_F(TLSSocketTest, TestTLSSocketWrite) {
   CompleteHandler handler;
   net::CompletionCallback callback;
 
-  EXPECT_CALL(*ssl_socket_, Write(_, _, _)).Times(2).WillRepeatedly(
-      DoAll(SaveArg<2>(&callback), Return(128)));
+  EXPECT_CALL(*ssl_socket_, Write(_, _, _, _))
+      .Times(2)
+      .WillRepeatedly(DoAll(SaveArg<2>(&callback), Return(128)));
   EXPECT_CALL(handler, OnComplete(_)).Times(1);
 
   scoped_refptr<net::IOBufferWithSize> io_buffer(
@@ -187,8 +193,10 @@ TEST_F(TLSSocketTest, TestTLSSocketBlockedWrite) {
 
   // Return ERR_IO_PENDING to say the Write()'s blocked. Save the |callback|
   // Write()'s passed.
-  EXPECT_CALL(*ssl_socket_, Write(_, _, _)).Times(2).WillRepeatedly(
-      DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
+  EXPECT_CALL(*ssl_socket_, Write(_, _, _, _))
+      .Times(2)
+      .WillRepeatedly(
+          DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
 
   scoped_refptr<net::IOBufferWithSize> io_buffer(new net::IOBufferWithSize(42));
   socket_->Write(
@@ -218,8 +226,10 @@ TEST_F(TLSSocketTest, TestTLSSocketBlockedWriteReentry) {
   // will all be equivalent), and return ERR_IO_PENDING, to indicate a blocked
   // request. The mocked SSLClientSocket::Write() will get one request per
   // TLSSocket::Write() request invoked on |socket_| below.
-  EXPECT_CALL(*ssl_socket_, Write(_, _, _)).Times(kNumIOs).WillRepeatedly(
-      DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
+  EXPECT_CALL(*ssl_socket_, Write(_, _, _, _))
+      .Times(kNumIOs)
+      .WillRepeatedly(
+          DoAll(SaveArg<2>(&callback), Return(net::ERR_IO_PENDING)));
 
   // Send out |kNuMIOs| requests, each with a different size.
   for (int i = 0; i < kNumIOs; i++) {
@@ -282,9 +292,10 @@ TEST_F(TLSSocketTest, TestTLSSocketLargeWrites) {
   // from Socket::Write(). If the callback is invoked with a smaller number,
   // Socket::WriteImpl() will get repeatedly invoked until the sum of the
   // callbacks' arguments is equal to the original requested amount.
-  EXPECT_CALL(*ssl_socket_, Write(_, _, _)).WillRepeatedly(
-      DoAll(WithArgs<2, 1>(Invoke(&pending_callbacks, &CallbackList::append)),
-            Return(net::ERR_IO_PENDING)));
+  EXPECT_CALL(*ssl_socket_, Write(_, _, _, _))
+      .WillRepeatedly(DoAll(
+          WithArgs<2, 1>(Invoke(&pending_callbacks, &CallbackList::append)),
+          Return(net::ERR_IO_PENDING)));
 
   // Observe what comes back from Socket::Write() here.
   EXPECT_CALL(handler, OnComplete(Gt(0))).Times(kNumIncrements);
diff --git a/chromium/chrome/browser/extensions/api/sockets_tcp_server/sockets_tcp_server_api_unittest.cc b/chromium/chrome/browser/extensions/api/sockets_tcp_server/sockets_tcp_server_api_unittest.cc
index dbcdc6a22ff..aa9e1e65408 100644
--- a/chromium/chrome/browser/extensions/api/sockets_tcp_server/sockets_tcp_server_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/sockets_tcp_server/sockets_tcp_server_api_unittest.cc
@@ -4,7 +4,6 @@
 
 #include <memory>
 
-#include "base/memory/ptr_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process_impl.h"
@@ -24,12 +23,12 @@ namespace api {
 
 static std::unique_ptr<KeyedService> ApiResourceManagerTestFactory(
     content::BrowserContext* context) {
-  return base::MakeUnique<ApiResourceManager<ResumableTCPSocket>>(context);
+  return std::make_unique<ApiResourceManager<ResumableTCPSocket>>(context);
 }
 
 static std::unique_ptr<KeyedService> ApiResourceManagerTestServerFactory(
     content::BrowserContext* context) {
-  return base::MakeUnique<ApiResourceManager<ResumableTCPServerSocket>>(
+  return std::make_unique<ApiResourceManager<ResumableTCPServerSocket>>(
       context);
 }
 
diff --git a/chromium/chrome/browser/extensions/api/storage/policy_value_store_unittest.cc b/chromium/chrome/browser/extensions/api/storage/policy_value_store_unittest.cc
index 6f9cce6d822..eb1b11aa4ee 100644
--- a/chromium/chrome/browser/extensions/api/storage/policy_value_store_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/storage/policy_value_store_unittest.cc
@@ -10,7 +10,6 @@
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/policy_map.h"
@@ -51,7 +50,7 @@ class MutablePolicyValueStore : public PolicyValueStore {
       : PolicyValueStore(
             kTestExtensionId,
             base::MakeRefCounted<SettingsObserverList>(),
-            base::MakeUnique<LeveldbValueStore>(kDatabaseUMAClientName, path)) {
+            std::make_unique<LeveldbValueStore>(kDatabaseUMAClientName, path)) {
   }
   ~MutablePolicyValueStore() override {}
 
@@ -102,7 +101,7 @@ class PolicyValueStoreTest : public testing::Test {
     observers_->AddObserver(&observer_);
     store_.reset(new PolicyValueStore(
         kTestExtensionId, observers_,
-        base::MakeUnique<LeveldbValueStore>(kDatabaseUMAClientName,
+        std::make_unique<LeveldbValueStore>(kDatabaseUMAClientName,
                                             scoped_temp_dir_.GetPath())));
   }
 
@@ -141,7 +140,7 @@ TEST_F(PolicyValueStoreTest, DontProvideRecommendedPolicies) {
                expected.CreateDeepCopy(), nullptr);
   policies.Set("may", policy::POLICY_LEVEL_RECOMMENDED,
                policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-               base::MakeUnique<base::Value>(456), nullptr);
+               std::make_unique<base::Value>(456), nullptr);
   SetCurrentPolicy(policies);
 
   ValueStore::ReadResult result = store_->Get();
diff --git a/chromium/chrome/browser/extensions/api/storage/settings_sync_unittest.cc b/chromium/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
index bcca9d1ab0d..8f135ec3859 100644
--- a/chromium/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
@@ -11,7 +11,6 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ -118,7 +117,7 @@ class MockSyncChangeProcessor : public syncer::SyncChangeProcessor {
     }
     for (syncer::SyncChangeList::const_iterator it = change_list.begin();
         it != change_list.end(); ++it) {
-      changes_.push_back(base::MakeUnique<SettingSyncData>(*it));
+      changes_.push_back(std::make_unique<SettingSyncData>(*it));
     }
     return syncer::SyncError();
   }
@@ -167,12 +166,12 @@ class MockSyncChangeProcessor : public syncer::SyncChangeProcessor {
 
 std::unique_ptr<KeyedService> MockExtensionSystemFactoryFunction(
     content::BrowserContext* context) {
-  return base::MakeUnique<MockExtensionSystem>(context);
+  return std::make_unique<MockExtensionSystem>(context);
 }
 
 std::unique_ptr<KeyedService> BuildEventRouter(
     content::BrowserContext* profile) {
-  return base::MakeUnique<extensions::EventRouter>(profile, nullptr);
+  return std::make_unique<extensions::EventRouter>(profile, nullptr);
 }
 
 }  // namespace
@@ -296,7 +295,7 @@ TEST_F(ExtensionSettingsSyncTest, NoDataDoesNotInvokeSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
   });
 
   AddExtensionAndGetStorage("s2", type);
@@ -342,7 +341,7 @@ TEST_F(ExtensionSettingsSyncTest, InSyncDataDoesNotInvokeSync) {
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     // Already in sync, so no changes.
     EXPECT_EQ(0u, sync_processor_->changes().size());
@@ -381,7 +380,7 @@ TEST_F(ExtensionSettingsSyncTest, LocalDataWithNoSyncDataIsPushedToSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     // All settings should have been pushed to sync.
     EXPECT_EQ(2u, sync_processor_->changes().size());
@@ -422,7 +421,7 @@ TEST_F(ExtensionSettingsSyncTest, AnySyncDataOverwritesLocalData) {
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
     expected1.Set("foo", value1.CreateDeepCopy());
     expected2.Set("bar", value2.CreateDeepCopy());
   });
@@ -468,7 +467,7 @@ TEST_F(ExtensionSettingsSyncTest, ProcessSyncChanges) {
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
     expected2.Set("bar", value2.CreateDeepCopy());
 
     // Make sync add some settings.
@@ -544,7 +543,7 @@ TEST_F(ExtensionSettingsSyncTest, PushToSync) {
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     // Add something locally.
     storage1->Set(DEFAULTS, "bar", value2);
@@ -685,7 +684,7 @@ TEST_F(ExtensionSettingsSyncTest, ExtensionAndAppSettingsSyncSeparately) {
         ->MergeDataAndStartSyncing(
             syncer::EXTENSION_SETTINGS, sync_data,
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
     GetSyncableService(syncer::EXTENSION_SETTINGS)
         ->StopSyncing(syncer::EXTENSION_SETTINGS);
     EXPECT_EQ(0u, sync_processor_->changes().size());
@@ -700,7 +699,7 @@ TEST_F(ExtensionSettingsSyncTest, ExtensionAndAppSettingsSyncSeparately) {
     GetSyncableService(syncer::APP_SETTINGS)
         ->MergeDataAndStartSyncing(
             syncer::APP_SETTINGS, sync_data, std::move(app_settings_delegate_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
     GetSyncableService(syncer::APP_SETTINGS)->StopSyncing(syncer::APP_SETTINGS);
     EXPECT_EQ(0u, sync_processor_->changes().size());
   });
@@ -732,7 +731,7 @@ TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
       GetSyncableService(model_type)
           ->MergeDataAndStartSyncing(
               model_type, sync_data, std::move(sync_processor_wrapper_),
-              base::MakeUnique<syncer::SyncErrorFactoryMock>());
+              std::make_unique<syncer::SyncErrorFactoryMock>());
     }
     GetExisting("bad")->set_status_code(ValueStore::OK);
 
@@ -850,7 +849,7 @@ TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     // Local settings will have been pushed to sync, since it's empty (in this
     // test; presumably it wouldn't be live, since we've been getting changes).
@@ -921,7 +920,7 @@ TEST_F(ExtensionSettingsSyncTest, FailingProcessChangesDisablesSync) {
       GetSyncableService(model_type)
           ->MergeDataAndStartSyncing(
               model_type, sync_data, std::move(sync_processor_wrapper_),
-              base::MakeUnique<syncer::SyncErrorFactoryMock>());
+              std::make_unique<syncer::SyncErrorFactoryMock>());
     }
 
     EXPECT_EQ(0u, sync_processor_->changes().size());
@@ -1026,7 +1025,7 @@ TEST_F(ExtensionSettingsSyncTest, FailingGetAllSyncDataDoesntStopSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
               sync_processor_->GetOnlyChange("good", "foo")->change_type());
@@ -1067,7 +1066,7 @@ TEST_F(ExtensionSettingsSyncTest, FailureToReadChangesToPushDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
     GetExisting("bad")->set_status_code(ValueStore::OK);
 
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
@@ -1118,7 +1117,7 @@ TEST_F(ExtensionSettingsSyncTest, FailureToReadChangesToPushDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
               sync_processor_->GetOnlyChange("good", "foo")->change_type());
@@ -1161,7 +1160,7 @@ TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalStateDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
     sync_processor_->set_fail_all_requests(false);
 
     // Changes from good will be send to sync, changes from bad won't.
@@ -1205,7 +1204,7 @@ TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalStateDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
               sync_processor_->GetOnlyChange("good", "foo")->change_type());
@@ -1242,7 +1241,7 @@ TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalChangeDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     // bad will fail to send changes.
     good->Set(DEFAULTS, "foo", fooValue);
@@ -1295,7 +1294,7 @@ TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalChangeDisablesSync) {
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
 
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
               sync_processor_->GetOnlyChange("good", "foo")->change_type());
@@ -1334,7 +1333,7 @@ TEST_F(ExtensionSettingsSyncTest,
         ->MergeDataAndStartSyncing(
             model_type, syncer::SyncDataList(),
             std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+            std::make_unique<syncer::SyncErrorFactoryMock>());
   });
 
   // Large local change rejected and doesn't get sent out.
@@ -1386,7 +1385,7 @@ TEST_F(ExtensionSettingsSyncTest, Dots) {
       GetSyncableService(model_type)
           ->MergeDataAndStartSyncing(
               model_type, sync_data_list, std::move(sync_processor_wrapper_),
-              base::MakeUnique<syncer::SyncErrorFactoryMock>());
+              std::make_unique<syncer::SyncErrorFactoryMock>());
     }
 
     // Test dots in keys that come from sync.
@@ -1396,7 +1395,7 @@ TEST_F(ExtensionSettingsSyncTest, Dots) {
 
       base::DictionaryValue expected_data;
       expected_data.SetWithoutPathExpansion(
-          "key.with.dot", base::MakeUnique<base::Value>("value"));
+          "key.with.dot", std::make_unique<base::Value>("value"));
       EXPECT_EQ(expected_data, data.settings());
     }
 
diff --git a/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.cc b/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.cc
index a22c63b73cd..7cb9a4b31c5 100644
--- a/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.cc
+++ b/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.cc
@@ -29,7 +29,7 @@ void AddAllSyncData(const std::string& extension_id,
 }
 
 std::unique_ptr<base::DictionaryValue> EmptyDictionaryValue() {
-  return base::MakeUnique<base::DictionaryValue>();
+  return std::make_unique<base::DictionaryValue>();
 }
 
 ValueStoreFactory::ModelType ToFactoryModelType(syncer::ModelType sync_type) {
diff --git a/chromium/chrome/browser/extensions/api/storage/syncable_settings_storage.cc b/chromium/chrome/browser/extensions/api/storage/syncable_settings_storage.cc
index 024631bc048..3778715f247 100644
--- a/chromium/chrome/browser/extensions/api/storage/syncable_settings_storage.cc
+++ b/chromium/chrome/browser/extensions/api/storage/syncable_settings_storage.cc
@@ -6,7 +6,6 @@
 
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
@@ -218,13 +217,13 @@ syncer::SyncError SyncableSettingsStorage::OverwriteLocalSettingsWithSync(
         // Sync and local values are the same, no changes to send.
       } else {
         // Sync value is different, update local setting with new value.
-        changes->push_back(base::MakeUnique<SettingSyncData>(
+        changes->push_back(std::make_unique<SettingSyncData>(
             syncer::SyncChange::ACTION_UPDATE, extension_id_, it.key(),
             std::move(sync_value)));
       }
     } else {
       // Not synced, delete local setting.
-      changes->push_back(base::MakeUnique<SettingSyncData>(
+      changes->push_back(std::make_unique<SettingSyncData>(
           syncer::SyncChange::ACTION_DELETE, extension_id_, it.key(),
           std::unique_ptr<base::Value>(new base::DictionaryValue())));
     }
@@ -237,7 +236,7 @@ syncer::SyncError SyncableSettingsStorage::OverwriteLocalSettingsWithSync(
     std::string key = base::DictionaryValue::Iterator(*sync_state).key();
     std::unique_ptr<base::Value> value;
     CHECK(sync_state->RemoveWithoutPathExpansion(key, &value));
-    changes->push_back(base::MakeUnique<SettingSyncData>(
+    changes->push_back(std::make_unique<SettingSyncData>(
         syncer::SyncChange::ACTION_ADD, extension_id_, key, std::move(value)));
   }
 
diff --git a/chromium/chrome/browser/extensions/api/streams_private/streams_private_apitest.cc b/chromium/chrome/browser/extensions/api/streams_private/streams_private_apitest.cc
index 23278aece13..b62b194dcff 100644
--- a/chromium/chrome/browser/extensions/api/streams_private/streams_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/streams_private/streams_private_apitest.cc
@@ -227,10 +227,9 @@ class StreamsPrivateApiTest : public ExtensionApiTest {
   // The |manager| should have |download| in its list of downloads.
   void DeleteDownloadAndWaitForFlush(DownloadItem* download,
                                      DownloadManager* manager) {
-    scoped_refptr<content::DownloadTestFlushObserver> flush_observer(
-        new content::DownloadTestFlushObserver(manager));
+    content::DownloadTestFlushObserver flush_observer(manager);
     download->Remove();
-    flush_observer->WaitForFlush();
+    flush_observer.WaitForFlush();
   }
 
  protected:
diff --git a/chromium/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc b/chromium/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc
index 83f5cd6108e..22ba2ed5481 100644
--- a/chromium/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc
+++ b/chromium/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc
@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.h"
 #include "chrome/browser/sync_file_system/sync_event_observer.h"
 #include "chrome/browser/sync_file_system/sync_file_system_service.h"
@@ -129,7 +128,7 @@ void ExtensionSyncEventObserver::BroadcastOrDispatchEvent(
   EventRouter* event_router = EventRouter::Get(browser_context_);
   DCHECK(event_router);
 
-  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+  auto event = std::make_unique<Event>(histogram_value, event_name,
                                        std::move(values), browser_context_);
 
   // No app_origin, broadcast to all listening extensions for this event name.
diff --git a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.cc b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.cc
index 647f7f40d9f..dd197836872 100644
--- a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.cc
+++ b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.cc
@@ -10,7 +10,6 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h"
 #include "chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.h"
@@ -67,6 +66,25 @@ std::string ErrorToString(SyncStatusCode code) {
       static_cast<int>(code));
 }
 
+const char* QuotaStatusCodeToString(blink::mojom::QuotaStatusCode status) {
+  switch (status) {
+    case blink::mojom::QuotaStatusCode::kOk:
+      return "OK.";
+    case blink::mojom::QuotaStatusCode::kErrorNotSupported:
+      return "Operation not supported.";
+    case blink::mojom::QuotaStatusCode::kErrorInvalidModification:
+      return "Invalid modification.";
+    case blink::mojom::QuotaStatusCode::kErrorInvalidAccess:
+      return "Invalid access.";
+    case blink::mojom::QuotaStatusCode::kErrorAbort:
+      return "Quota operation aborted.";
+    case blink::mojom::QuotaStatusCode::kUnknown:
+      return "Unknown error.";
+  }
+  NOTREACHED();
+  return "Unknown error.";
+}
+
 }  // namespace
 
 bool SyncFileSystemDeleteFileSystemFunction::RunAsync() {
@@ -105,12 +123,12 @@ void SyncFileSystemDeleteFileSystemFunction::DidDeleteFileSystem(
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (error != base::File::FILE_OK) {
     error_ = ErrorToString(sync_file_system::FileErrorToSyncStatusCode(error));
-    SetResult(base::MakeUnique<base::Value>(false));
+    SetResult(std::make_unique<base::Value>(false));
     SendResponse(false);
     return;
   }
 
-  SetResult(base::MakeUnique<base::Value>(true));
+  SetResult(std::make_unique<base::Value>(true));
   SendResponse(true);
 }
 
@@ -323,7 +341,7 @@ bool SyncFileSystemGetUsageAndQuotaFunction::RunAsync() {
 }
 
 void SyncFileSystemGetUsageAndQuotaFunction::DidGetUsageAndQuota(
-    storage::QuotaStatusCode status,
+    blink::mojom::QuotaStatusCode status,
     int64_t usage,
     int64_t quota) {
   // Repost to switch from IO thread to UI thread for SendResponse().
@@ -337,7 +355,7 @@ void SyncFileSystemGetUsageAndQuotaFunction::DidGetUsageAndQuota(
   }
 
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (status != storage::kQuotaStatusOk) {
+  if (status != blink::mojom::QuotaStatusCode::kOk) {
     error_ = QuotaStatusCodeToString(status);
     SendResponse(false);
     return;
@@ -366,7 +384,7 @@ SyncFileSystemSetConflictResolutionPolicyFunction::Run() {
 ExtensionFunction::ResponseAction
 SyncFileSystemGetConflictResolutionPolicyFunction::Run() {
   return RespondNow(
-      OneArgument(base::MakeUnique<base::Value>(api::sync_file_system::ToString(
+      OneArgument(std::make_unique<base::Value>(api::sync_file_system::ToString(
           api::sync_file_system::CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN))));
 }
 
diff --git a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.h b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.h
index 9863c8f95a7..cb4ad6f0b90 100644
--- a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.h
+++ b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api.h
@@ -15,7 +15,7 @@
 #include "chrome/browser/sync_file_system/sync_status_code.h"
 #include "chrome/common/extensions/api/sync_file_system.h"
 #include "storage/browser/fileapi/file_system_url.h"
-#include "storage/common/quota/quota_types.h"
+#include "third_party/WebKit/common/quota/quota_types.mojom.h"
 
 namespace storage {
 class FileSystemContext;
@@ -93,7 +93,7 @@ class SyncFileSystemGetUsageAndQuotaFunction
   bool RunAsync() override;
 
  private:
-  void DidGetUsageAndQuota(storage::QuotaStatusCode status,
+  void DidGetUsageAndQuota(blink::mojom::QuotaStatusCode status,
                            int64_t usage,
                            int64_t quota);
 };
diff --git a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.cc b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.cc
index c191b3d18a9..fa0cac5c66d 100644
--- a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.cc
@@ -5,7 +5,6 @@
 #include "chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.h"
 
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "storage/browser/fileapi/file_system_url.h"
 #include "storage/common/fileapi/file_system_util.h"
@@ -124,7 +123,7 @@ std::unique_ptr<base::DictionaryValue> CreateDictionaryValueForFileSystemEntry(
     root_url.append("/");
   }
 
-  auto dict = base::MakeUnique<base::DictionaryValue>();
+  auto dict = std::make_unique<base::DictionaryValue>();
   dict->SetString("fileSystemType",
                   storage::GetFileSystemTypeString(url.mount_type()));
   dict->SetString("fileSystemName",
diff --git a/chromium/chrome/browser/extensions/api/system_private/system_private_api.cc b/chromium/chrome/browser/extensions/api/system_private/system_private_api.cc
index 730d1de7aaf..e6f5f4d803b 100644
--- a/chromium/chrome/browser/extensions/api/system_private/system_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/system_private/system_private_api.cc
@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
@@ -80,7 +79,7 @@ SystemPrivateGetIncognitoModeAvailabilityFunction::Run() {
       value >= 0 &&
       value < static_cast<int>(arraysize(kIncognitoModeAvailabilityStrings)));
   return RespondNow(OneArgument(
-      base::MakeUnique<base::Value>(kIncognitoModeAvailabilityStrings[value])));
+      std::make_unique<base::Value>(kIncognitoModeAvailabilityStrings[value])));
 }
 
 ExtensionFunction::ResponseAction SystemPrivateGetUpdateStatusFunction::Run() {
@@ -147,7 +146,7 @@ ExtensionFunction::ResponseAction SystemPrivateGetUpdateStatusFunction::Run() {
 
 ExtensionFunction::ResponseAction SystemPrivateGetApiKeyFunction::Run() {
   return RespondNow(
-      OneArgument(base::MakeUnique<base::Value>(google_apis::GetAPIKey())));
+      OneArgument(std::make_unique<base::Value>(google_apis::GetAPIKey())));
 }
 
 void DispatchVolumeChangedEvent(double volume, bool is_volume_muted) {
diff --git a/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.cc b/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.cc
index 12a46ca8ed3..0f2740e7939 100644
--- a/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.cc
+++ b/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.cc
@@ -5,23 +5,22 @@
 #include "chrome/browser/extensions/api/tab_capture/offscreen_tab.h"
 
 #include <algorithm>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
-#include "chrome/browser/media/router/receiver_presentation_service_delegate_impl.h"  // nogncheck
+#include "chrome/browser/media/router/presentation/presentation_navigation_policy.h"
+#include "chrome/browser/media/router/presentation/receiver_presentation_service_delegate_impl.h"  // nogncheck
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/web_contents_sizer.h"
 #include "content/public/browser/keyboard_event_processing_result.h"
 #include "content/public/browser/navigation_handle.h"
-#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
-#include "content/public/common/web_preferences.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/process_manager.h"
 #include "third_party/WebKit/public/web/WebPresentationReceiverFlags.h"
@@ -41,10 +40,6 @@ const int kMaxOffscreenTabsPerExtension = 4;
 const int kMaxSecondsToWaitForCapture = 60;
 const int kPollIntervalInSeconds = 1;
 
-typedef std::vector<content::BrowserContext*> BrowserContextList;
-static base::LazyInstance<BrowserContextList>::Leaky g_offscreen_profiles =
-    LAZY_INSTANCE_INITIALIZER;
-
 }  // namespace
 
 namespace extensions {
@@ -64,13 +59,6 @@ OffscreenTabsOwner* OffscreenTabsOwner::Get(
   return FromWebContents(extension_web_contents);
 }
 
-// static
-bool OffscreenTabsOwner::IsOffscreenProfile(const Profile* profile) {
-  const BrowserContextList& offscreen_profiles = g_offscreen_profiles.Get();
-  return std::find(offscreen_profiles.begin(), offscreen_profiles.end(),
-                   profile) != offscreen_profiles.end();
-}
-
 OffscreenTab* OffscreenTabsOwner::OpenNewTab(
     const GURL& start_url,
     const gfx::Size& initial_size,
@@ -98,48 +86,23 @@ void OffscreenTabsOwner::DestroyTab(OffscreenTab* tab) {
   }
 }
 
-// Navigation policy for presentations, where top-level navigations are not
-// allowed.
-class OffscreenTab::PresentationNavigationPolicy
-    : public OffscreenTab::NavigationPolicy {
- public:
-  PresentationNavigationPolicy() : first_navigation_started_(false) {}
-  ~PresentationNavigationPolicy() override = default;
-
- private:
-  // OffscreenTab::NavigationPolicy overrides
-  bool DidStartNavigation(content::NavigationHandle* navigation_handle) final {
-    // We only care about top-level navigations that are cross-document.
-    if (!navigation_handle->IsInMainFrame() ||
-        navigation_handle->IsSameDocument()) {
-      return true;
-    }
-
-    // The initial navigation had already begun.
-    if (first_navigation_started_)
-      return false;
-
-    first_navigation_started_ = true;
-    return true;
-  }
-
-  bool first_navigation_started_;
-};
-
 OffscreenTab::OffscreenTab(OffscreenTabsOwner* owner)
     : owner_(owner),
-      profile_(Profile::FromBrowserContext(
-                   owner->extension_web_contents()->GetBrowserContext())
-                   ->CreateOffTheRecordProfile()),
+      otr_profile_registration_(
+          IndependentOTRProfileManager::GetInstance()
+              ->CreateFromOriginalProfile(
+                  Profile::FromBrowserContext(
+                      owner->extension_web_contents()->GetBrowserContext()),
+                  base::BindOnce(&OffscreenTab::DieIfOriginalProfileDestroyed,
+                                 base::Unretained(this)))),
       capture_poll_timer_(false, false),
       content_capture_was_detected_(false),
-      navigation_policy_(new NavigationPolicy) {
-  DCHECK(profile_);
-  g_offscreen_profiles.Get().push_back(profile_.get());
+      navigation_policy_(
+          std::make_unique<media_router::DefaultNavigationPolicy>()) {
+  DCHECK(otr_profile_registration_->profile());
 }
 
 OffscreenTab::~OffscreenTab() {
-  base::Erase(g_offscreen_profiles.Get(), profile_.get());
   DVLOG(1) << "Destroying OffscreenTab for start_url=" << start_url_.spec();
 }
 
@@ -152,7 +115,7 @@ void OffscreenTab::Start(const GURL& start_url,
            << initial_size.ToString() << " for start_url=" << start_url_.spec();
 
   // Create the WebContents to contain the off-screen tab's page.
-  WebContents::CreateParams params(profile_.get());
+  WebContents::CreateParams params(otr_profile_registration_->profile());
   if (!optional_presentation_id.empty())
     params.starting_sandbox_flags = blink::kPresentationReceiverSandboxFlags;
 
@@ -182,17 +145,11 @@ void OffscreenTab::Start(const GURL& start_url,
     media_router::ReceiverPresentationServiceDelegateImpl::CreateForWebContents(
         offscreen_tab_web_contents_.get(), optional_presentation_id);
 
-    if (auto* render_view_host =
-            offscreen_tab_web_contents_->GetRenderViewHost()) {
-      auto web_prefs = render_view_host->GetWebkitPreferences();
-      web_prefs.presentation_receiver = true;
-      render_view_host->UpdateWebkitPreferences(web_prefs);
-    }
-
     // Presentations are not allowed to perform top-level navigations after
     // initial load.  This is enforced through sandboxing flags, but we also
     // enforce it here.
-    navigation_policy_.reset(new PresentationNavigationPolicy);
+    navigation_policy_ =
+        std::make_unique<media_router::PresentationNavigationPolicy>();
   }
 
   // Navigate to the initial URL.
@@ -315,10 +272,8 @@ void OffscreenTab::EnterFullscreenModeForTab(WebContents* contents,
 
   non_fullscreen_size_ =
       contents->GetRenderWidgetHostView()->GetViewBounds().size();
-  if (contents->GetCapturerCount() >= 0 &&
-      !contents->GetPreferredSize().IsEmpty()) {
+  if (contents->IsBeingCaptured() && !contents->GetPreferredSize().IsEmpty())
     ResizeWebContents(contents, gfx::Rect(contents->GetPreferredSize()));
-  }
 }
 
 void OffscreenTab::ExitFullscreenModeForTab(WebContents* contents) {
@@ -401,7 +356,7 @@ bool OffscreenTab::CheckMediaAccessPermission(
 }
 
 void OffscreenTab::DidShowFullscreenWidget() {
-  if (offscreen_tab_web_contents_->GetCapturerCount() == 0 ||
+  if (!offscreen_tab_web_contents_->IsBeingCaptured() ||
       offscreen_tab_web_contents_->GetPreferredSize().IsEmpty())
     return;  // Do nothing, since no preferred size is specified.
   content::RenderWidgetHostView* const current_fs_view =
@@ -413,27 +368,18 @@ void OffscreenTab::DidShowFullscreenWidget() {
 void OffscreenTab::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   DCHECK(offscreen_tab_web_contents_.get());
-  if (!navigation_policy_->DidStartNavigation(navigation_handle)) {
+  if (!navigation_policy_->AllowNavigation(navigation_handle)) {
     DVLOG(2) << "Closing because NavigationPolicy disallowed "
              << "StartNavigation to " << navigation_handle->GetURL().spec();
     Close();
   }
 }
 
-// Default navigation policy.
-OffscreenTab::NavigationPolicy::NavigationPolicy() = default;
-OffscreenTab::NavigationPolicy::~NavigationPolicy() = default;
-
-bool OffscreenTab::NavigationPolicy::DidStartNavigation(
-    content::NavigationHandle* navigation_handle) {
-  return true;
-}
-
 void OffscreenTab::DieIfContentCaptureEnded() {
   DCHECK(offscreen_tab_web_contents_.get());
 
   if (content_capture_was_detected_) {
-    if (offscreen_tab_web_contents_->GetCapturerCount() == 0) {
+    if (!offscreen_tab_web_contents_->IsBeingCaptured()) {
       DVLOG(2) << "Capture of OffscreenTab content has stopped for start_url="
                << start_url_.spec();
       owner_->DestroyTab(this);
@@ -442,7 +388,7 @@ void OffscreenTab::DieIfContentCaptureEnded() {
       DVLOG(3) << "Capture of OffscreenTab content continues for start_url="
                << start_url_.spec();
     }
-  } else if (offscreen_tab_web_contents_->GetCapturerCount() > 0) {
+  } else if (offscreen_tab_web_contents_->IsBeingCaptured()) {
     DVLOG(2) << "Capture of OffscreenTab content has started for start_url="
              << start_url_.spec();
     content_capture_was_detected_ = true;
@@ -466,4 +412,9 @@ void OffscreenTab::DieIfContentCaptureEnded() {
                  base::Unretained(this)));
 }
 
+void OffscreenTab::DieIfOriginalProfileDestroyed(Profile* profile) {
+  DCHECK(profile == otr_profile_registration_->profile());
+  owner_->DestroyTab(this);
+}
+
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.h b/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.h
index 9e313241ff3..f302682ee4c 100644
--- a/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.h
+++ b/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.h
@@ -7,18 +7,22 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
+#include "chrome/browser/media/router/presentation/independent_otr_profile_manager.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "ui/gfx/geometry/size.h"
 
-class Profile;
+namespace media_router {
+class NavigationPolicy;
+}  // namespace media_router
 
 namespace extensions {
 
@@ -44,10 +48,6 @@ class OffscreenTabsOwner
   // background page's WebContents.  Never returns nullptr.
   static OffscreenTabsOwner* Get(content::WebContents* extension_web_contents);
 
-  // Returns |true| if |profile| is associated with an offscreen tab, false
-  // otherwise.
-  static bool IsOffscreenProfile(const Profile* profile);
-
   // Instantiate a new offscreen tab and navigate it to |start_url|.  The new
   // tab's main frame will start out with the given |initial_size| in DIP
   // coordinates.  If too many offscreen tabs are already running, nothing
@@ -56,10 +56,9 @@ class OffscreenTabsOwner
   // If |optional_presentation_id| is non-empty, the offscreen tab is registered
   // for use by the Media Router (chrome/browser/media/router/...) as the
   // receiving browsing context for the W3C Presentation API.
-  OffscreenTab* OpenNewTab(
-      const GURL& start_url,
-      const gfx::Size& initial_size,
-      const std::string& optional_presentation_id);
+  OffscreenTab* OpenNewTab(const GURL& start_url,
+                           const gfx::Size& initial_size,
+                           const std::string& optional_presentation_id);
 
  protected:
   friend class OffscreenTab;
@@ -91,10 +90,10 @@ class OffscreenTabsOwner
 // OffscreenTab is instantiated by OffscreenTabsOwner.  An instance is shut down
 // one of three ways:
 //
-//   1. When its WebContents::GetCapturerCount() returns to zero, indicating
-//      there are no more consumers of its captured content (e.g., when all
-//      MediaStreams have been closed).  OffscreenTab will auto-detect this case
-//      and self-destruct.
+//   1. When WebContents::IsBeingCaptured() returns false, indicating there are
+//      no more consumers of its captured content (e.g., when all MediaStreams
+//      have been closed).  OffscreenTab will auto-detect this case and
+//      self-destruct.
 //   2. By the renderer, where the WebContents implementation will invoke the
 //      WebContentsDelegate::CloseContents() override.  This occurs, for
 //      example, when a page calls window.close().
@@ -180,28 +179,16 @@ class OffscreenTab : protected content::WebContentsDelegate,
   void DidStartNavigation(content::NavigationHandle* navigation_handle) final;
 
  private:
-  bool in_fullscreen_mode() const {
-    return !non_fullscreen_size_.IsEmpty();
-  }
-
-  // Selected calls to the navigation methods in WebContentsObserver are
-  // delegated to this object to determine a navigation is allowed.  If any
-  // call returns false, the offscreen tab is destroyed.  The default policy
-  // allows all navigations.
-  class NavigationPolicy {
-   public:
-    NavigationPolicy();
-    virtual ~NavigationPolicy();
-    virtual bool DidStartNavigation(
-        content::NavigationHandle* navigation_handle);
-  };
-
-  class PresentationNavigationPolicy;  // Forward declaration
+  bool in_fullscreen_mode() const { return !non_fullscreen_size_.IsEmpty(); }
 
   // Called by |capture_poll_timer_| to automatically destroy this OffscreenTab
   // when the capturer count returns to zero.
   void DieIfContentCaptureEnded();
 
+  // Called if the profile that our OTR profile is based on is being destroyed
+  // and |this| therefore needs to be destroyed also.
+  void DieIfOriginalProfileDestroyed(Profile* profile);
+
   OffscreenTabsOwner* const owner_;
 
   // The initial navigation URL, which may or may not match the current URL if
@@ -210,7 +197,8 @@ class OffscreenTab : protected content::WebContentsDelegate,
 
   // A non-shared off-the-record profile based on the profile of the extension
   // background page.
-  const std::unique_ptr<Profile> profile_;
+  const std::unique_ptr<IndependentOTRProfileManager::OTRProfileRegistration>
+      otr_profile_registration_;
 
   // The WebContents containing the off-screen tab's page.
   std::unique_ptr<content::WebContents> offscreen_tab_web_contents_;
@@ -236,7 +224,7 @@ class OffscreenTab : protected content::WebContentsDelegate,
   bool content_capture_was_detected_;
 
   // Object consulted to determine which offscreen tab navigations are allowed.
-  std::unique_ptr<NavigationPolicy> navigation_policy_;
+  std::unique_ptr<media_router::NavigationPolicy> navigation_policy_;
 
   DISALLOW_COPY_AND_ASSIGN(OffscreenTab);
 };
diff --git a/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc b/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc
index 5df6422ec0c..6cd50621778 100644
--- a/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc
+++ b/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_registry.cc
@@ -4,11 +4,11 @@
 
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
@@ -314,7 +314,7 @@ bool TabCaptureRegistry::AddRequest(content::WebContents* target_contents,
     }
   }
 
-  requests_.push_back(base::MakeUnique<LiveRequest>(
+  requests_.push_back(std::make_unique<LiveRequest>(
       target_contents, extension_id, is_anonymous, this));
   return true;
 }
@@ -427,7 +427,7 @@ void TabCaptureRegistry::DispatchStatusChangeEvent(
   tab_capture::CaptureInfo info;
   request->GetCaptureInfo(&info);
   args->Append(info.ToValue());
-  auto event = base::MakeUnique<Event>(events::TAB_CAPTURE_ON_STATUS_CHANGED,
+  auto event = std::make_unique<Event>(events::TAB_CAPTURE_ON_STATUS_CHANGED,
                                        tab_capture::OnStatusChanged::kEventName,
                                        std::move(args), browser_context_);
 
diff --git a/chromium/chrome/browser/extensions/api/tabs/app_window_controller.cc b/chromium/chrome/browser/extensions/api/tabs/app_window_controller.cc
index bc8272b8417..3d0bd3e606b 100644
--- a/chromium/chrome/browser/extensions/api/tabs/app_window_controller.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/app_window_controller.cc
@@ -7,7 +7,6 @@
 #include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/tabs/app_base_window.h"
@@ -57,7 +56,7 @@ AppWindowController::CreateWindowValueWithTabs(
   if (!tab_value)
     return result;
 
-  auto tab_list = base::MakeUnique<base::ListValue>();
+  auto tab_list = std::make_unique<base::ListValue>();
   tab_list->Append(std::move(tab_value));
   result->Set(tabs_constants::kTabsKey, std::move(tab_list));
 
diff --git a/chromium/chrome/browser/extensions/api/tabs/tabs_api.cc b/chromium/chrome/browser/extensions/api/tabs/tabs_api.cc
index 7d4252bc171..e802ba0057a 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_api.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_api.cc
@@ -15,7 +15,6 @@
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
@@ -96,6 +95,7 @@
 #include "ui/base/ui_base_types.h"
 
 #if defined(OS_CHROMEOS)
+#include "ash/public/cpp/window_pin_type.h"
 #include "ash/public/cpp/window_properties.h"
 #include "ash/public/interfaces/window_pin_type.mojom.h"
 #include "chrome/browser/ui/browser_command_controller.h"
@@ -256,12 +256,6 @@ bool IsValidStateForWindowsCreateFunction(
 }
 
 #if defined(OS_CHROMEOS)
-bool IsWindowTrustedPinned(ui::BaseWindow* base_window) {
-  aura::Window* window = base_window->GetNativeWindow();
-  ash::mojom::WindowPinType type = window->GetProperty(ash::kWindowPinTypeKey);
-  return type == ash::mojom::WindowPinType::TRUSTED_PINNED;
-}
-
 void SetWindowTrustedPinned(ui::BaseWindow* base_window, bool trusted_pinned) {
   aura::Window* window = base_window->GetNativeWindow();
   // TRUSTED_PINNED is used here because that one locks the window fullscreen
@@ -427,7 +421,7 @@ bool WindowsCreateFunction::ShouldOpenIncognitoWindow(
   if (incognito && !profile->IsGuestSession()) {
     std::string first_url_erased;
     for (size_t i = 0; i < urls->size();) {
-      if (chrome::IsURLAllowedInIncognito((*urls)[i], profile)) {
+      if (IsURLAllowedInIncognito((*urls)[i], profile)) {
         i++;
       } else {
         if (first_url_erased.empty())
@@ -605,8 +599,7 @@ ExtensionFunction::ResponseAction WindowsCreateFunction::Run() {
   Browser* new_window = new Browser(create_params);
 
   for (const GURL& url : urls) {
-    chrome::NavigateParams navigate_params(new_window, url,
-                                           ui::PAGE_TRANSITION_LINK);
+    NavigateParams navigate_params(new_window, url, ui::PAGE_TRANSITION_LINK);
     navigate_params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
 
     // Depending on the |setSelfAsOpener| option, we need to put the new
@@ -618,7 +611,7 @@ ExtensionFunction::ResponseAction WindowsCreateFunction::Run() {
     navigate_params.source_site_instance =
         render_frame_host()->GetSiteInstance();
 
-    chrome::Navigate(&navigate_params);
+    Navigate(&navigate_params);
   }
 
   WebContents* contents = NULL;
@@ -663,7 +656,7 @@ ExtensionFunction::ResponseAction WindowsCreateFunction::Run() {
       !browser_context()->IsOffTheRecord() && !include_incognito()) {
     // Don't expose incognito windows if extension itself works in non-incognito
     // profile and CanCrossIncognito isn't allowed.
-    result = base::MakeUnique<base::Value>();
+    result = std::make_unique<base::Value>();
   } else {
     result = controller->CreateWindowValueWithTabs(extension());
   }
@@ -690,7 +683,7 @@ ExtensionFunction::ResponseAction WindowsUpdateFunction::Run() {
 
 #if defined(OS_CHROMEOS)
   const bool is_window_trusted_pinned =
-      IsWindowTrustedPinned(controller->window());
+      ash::IsWindowTrustedPinned(controller->window());
   // Don't allow locked fullscreen operations on a window without the proper
   // permission (also don't allow any operations on a locked window if the
   // extension doesn't have the permission).
@@ -817,7 +810,7 @@ ExtensionFunction::ResponseAction WindowsRemoveFunction::Run() {
   }
 
 #if defined(OS_CHROMEOS)
-  if (IsWindowTrustedPinned(controller->window()) &&
+  if (ash::IsWindowTrustedPinned(controller->window()) &&
       !ExtensionHasLockedFullscreenPermission(extension())) {
     return RespondNow(
         Error(keys::kMissingLockWindowFullscreenPrivatePermission));
@@ -1261,8 +1254,7 @@ bool TabsUpdateFunction::RunAsync() {
   if (params->update_properties.url.get()) {
     std::string updated_url = *params->update_properties.url;
     if (browser->profile()->GetProfileType() == Profile::INCOGNITO_PROFILE &&
-        !chrome::IsURLAllowedInIncognito(GURL(updated_url),
-                                         browser->profile())) {
+        !IsURLAllowedInIncognito(GURL(updated_url), browser->profile())) {
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kURLsNotAllowedInIncognitoError, updated_url);
       return false;
@@ -1751,7 +1743,7 @@ void TabsCaptureVisibleTabFunction::OnCaptureSuccess(const SkBitmap& bitmap) {
     return;
   }
 
-  SetResult(base::MakeUnique<base::Value>(base64_result));
+  SetResult(std::make_unique<base::Value>(base64_result));
   SendResponse(true);
 }
 
@@ -1861,7 +1853,7 @@ void TabsDetectLanguageFunction::Observe(
 }
 
 void TabsDetectLanguageFunction::GotLanguage(const std::string& language) {
-  SetResult(base::MakeUnique<base::Value>(language));
+  SetResult(std::make_unique<base::Value>(language));
   SendResponse(true);
 
   Release();  // Balanced in Run()
diff --git a/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.cc b/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.cc
index d9d98896180..1ab063b1ea9 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.cc
@@ -9,7 +9,6 @@
 #include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
@@ -50,12 +49,12 @@ bool WillDispatchTabUpdatedEvent(
 
   std::unique_ptr<base::DictionaryValue> tab_value = tab_object->ToValue();
 
-  auto changed_properties = base::MakeUnique<base::DictionaryValue>();
+  auto changed_properties = std::make_unique<base::DictionaryValue>();
   const base::Value* value = nullptr;
   for (const auto& property : changed_property_names) {
     if (tab_value->Get(property, &value))
       changed_properties->Set(property,
-                              base::MakeUnique<base::Value>(value->Clone()));
+                              std::make_unique<base::Value>(value->Clone()));
   }
 
   event->event_args->Set(1, std::move(changed_properties));
@@ -160,7 +159,7 @@ void TabsEventRouter::RegisterForTabNotifications(WebContents* contents) {
 
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   DCHECK(tab_entries_.find(tab_id) == tab_entries_.end());
-  tab_entries_[tab_id] = base::MakeUnique<TabEntry>(this, contents);
+  tab_entries_[tab_id] = std::make_unique<TabEntry>(this, contents);
 }
 
 void TabsEventRouter::UnregisterForTabNotifications(WebContents* contents) {
@@ -203,7 +202,7 @@ void TabsEventRouter::TabCreatedAt(WebContents* contents,
                                    bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   std::unique_ptr<base::ListValue> args(new base::ListValue);
-  auto event = base::MakeUnique<Event>(events::TABS_ON_CREATED,
+  auto event = std::make_unique<Event>(events::TABS_ON_CREATED,
                                        tabs::OnCreated::kEventName,
                                        std::move(args), profile);
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
@@ -236,9 +235,9 @@ void TabsEventRouter::TabInsertedAt(TabStripModel* tab_strip_model,
       new base::DictionaryValue());
   object_args->Set(
       tabs_constants::kNewWindowIdKey,
-      base::MakeUnique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
+      std::make_unique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tabs_constants::kNewPositionKey,
-                   base::MakeUnique<Value>(index));
+                   std::make_unique<Value>(index));
   args->Append(std::move(object_args));
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
@@ -259,9 +258,9 @@ void TabsEventRouter::TabDetachedAt(WebContents* contents, int index) {
       new base::DictionaryValue());
   object_args->Set(
       tabs_constants::kOldWindowIdKey,
-      base::MakeUnique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
+      std::make_unique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tabs_constants::kOldPositionKey,
-                   base::MakeUnique<Value>(index));
+                   std::make_unique<Value>(index));
   args->Append(std::move(object_args));
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
@@ -296,13 +295,13 @@ void TabsEventRouter::ActiveTabChanged(WebContents* old_contents,
                                        WebContents* new_contents,
                                        int index,
                                        int reason) {
-  auto args = base::MakeUnique<base::ListValue>();
+  auto args = std::make_unique<base::ListValue>();
   int tab_id = ExtensionTabUtil::GetTabId(new_contents);
   args->AppendInteger(tab_id);
 
-  auto object_args = base::MakeUnique<base::DictionaryValue>();
+  auto object_args = std::make_unique<base::DictionaryValue>();
   object_args->Set(tabs_constants::kWindowIdKey,
-                   base::MakeUnique<Value>(
+                   std::make_unique<Value>(
                        ExtensionTabUtil::GetWindowIdOfTab(new_contents)));
   args->Append(object_args->CreateDeepCopy());
 
@@ -321,8 +320,8 @@ void TabsEventRouter::ActiveTabChanged(WebContents* old_contents,
                 tabs::OnActiveChanged::kEventName, std::move(args), gesture);
 
   // The onActivated event takes one argument: {windowId, tabId}.
-  auto on_activated_args = base::MakeUnique<base::ListValue>();
-  object_args->Set(tabs_constants::kTabIdKey, base::MakeUnique<Value>(tab_id));
+  auto on_activated_args = std::make_unique<base::ListValue>();
+  object_args->Set(tabs_constants::kTabIdKey, std::make_unique<Value>(tab_id));
   on_activated_args->Append(std::move(object_args));
   DispatchEvent(profile, events::TABS_ON_ACTIVATED,
                 tabs::OnActivated::kEventName, std::move(on_activated_args),
@@ -350,7 +349,7 @@ void TabsEventRouter::TabSelectionChanged(
 
   select_info->Set(
       tabs_constants::kWindowIdKey,
-      base::MakeUnique<Value>(
+      std::make_unique<Value>(
           ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
 
   select_info->Set(tabs_constants::kTabIdsKey, std::move(all_tabs));
@@ -377,11 +376,11 @@ void TabsEventRouter::TabMoved(WebContents* contents,
       new base::DictionaryValue());
   object_args->Set(
       tabs_constants::kWindowIdKey,
-      base::MakeUnique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
+      std::make_unique<Value>(ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tabs_constants::kFromIndexKey,
-                   base::MakeUnique<Value>(from_index));
+                   std::make_unique<Value>(from_index));
   object_args->Set(tabs_constants::kToIndexKey,
-                   base::MakeUnique<Value>(to_index));
+                   std::make_unique<Value>(to_index));
   args->Append(std::move(object_args));
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
@@ -426,7 +425,7 @@ void TabsEventRouter::DispatchEvent(
   if (!profile_->IsSameProfile(profile) || !event_router)
     return;
 
-  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+  auto event = std::make_unique<Event>(histogram_value, event_name,
                                        std::move(args), profile);
   event->user_gesture = user_gesture;
   event_router->BroadcastEvent(std::move(event));
@@ -453,7 +452,7 @@ void TabsEventRouter::DispatchTabUpdatedEvent(
   // WillDispatchTabUpdatedEvent.
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 
-  auto event = base::MakeUnique<Event>(events::TABS_ON_UPDATED,
+  auto event = std::make_unique<Event>(events::TABS_ON_UPDATED,
                                        tabs::OnUpdated::kEventName,
                                        std::move(args_base), profile);
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
diff --git a/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.h b/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.h
index fe7325c18da..7f0ac1eec90 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.h
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.h
@@ -39,7 +39,7 @@ namespace extensions {
 // extension processes in the same profile.
 class TabsEventRouter : public TabStripModelObserver,
                         public BrowserTabStripTrackerDelegate,
-                        public chrome::BrowserListObserver,
+                        public BrowserListObserver,
                         public favicon::FaviconDriverObserver,
                         public zoom::ZoomObserver,
                         public resource_coordinator::TabLifecycleObserver {
@@ -50,7 +50,7 @@ class TabsEventRouter : public TabStripModelObserver,
   // BrowserTabStripTrackerDelegate:
   bool ShouldTrackBrowser(Browser* browser) override;
 
-  // chrome::BrowserListObserver:
+  // BrowserListObserver:
   void OnBrowserSetLastActive(Browser* browser) override;
 
   // TabStripModelObserver:
diff --git a/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc b/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc
index 11602682e0b..01abcd19bea 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc
@@ -2306,8 +2306,10 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, WindowsCreate_NoOpener) {
       &opener_as_bool));
   EXPECT_FALSE(opener_as_bool);
 
-  // TODO(lukasza): http://crbug.com/718489: Verify that |new_contents| can NOT
-  // find |old_contents| using window.open/name.
+  // TODO(lukasza): http://crbug.com/786411: Verify that |new_contents| can NOT
+  // find |old_contents| using window.open/name.  This is currently broken,
+  // because browsing instance boundaries are pierced for all extension frames
+  // (we hope this can be limited to background pages / contents).
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/tabs/windows_event_router.cc b/chromium/chrome/browser/extensions/api/tabs/windows_event_router.cc
index e24c1c698c3..0ef3e6f98d1 100644
--- a/chromium/chrome/browser/extensions/api/tabs/windows_event_router.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/windows_event_router.cc
@@ -6,7 +6,6 @@
 
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -254,9 +253,9 @@ void WindowsEventRouter::OnActiveWindowChanged(
   if (!HasEventListener(windows::OnFocusChanged::kEventName))
     return;
 
-  std::unique_ptr<Event> event = base::MakeUnique<Event>(
+  std::unique_ptr<Event> event = std::make_unique<Event>(
       events::WINDOWS_ON_FOCUS_CHANGED, windows::OnFocusChanged::kEventName,
-      base::MakeUnique<base::ListValue>());
+      std::make_unique<base::ListValue>());
   event->will_dispatch_callback =
       base::Bind(&WillDispatchWindowFocusedEvent, window_controller);
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
@@ -267,7 +266,7 @@ void WindowsEventRouter::DispatchEvent(events::HistogramValue histogram_value,
                                        WindowController* window_controller,
                                        std::unique_ptr<base::ListValue> args) {
   auto event =
-      base::MakeUnique<Event>(histogram_value, event_name, std::move(args),
+      std::make_unique<Event>(histogram_value, event_name, std::move(args),
                               window_controller->profile());
   event->will_dispatch_callback =
       base::Bind(&WillDispatchWindowEvent, window_controller);
@@ -280,7 +279,7 @@ bool WindowsEventRouter::HasEventListener(const std::string& event_name) {
 
 void WindowsEventRouter::AddAppWindow(extensions::AppWindow* app_window) {
   std::unique_ptr<AppWindowController> controller(new AppWindowController(
-      app_window, base::MakeUnique<AppBaseWindow>(app_window), profile_));
+      app_window, std::make_unique<AppBaseWindow>(app_window), profile_));
   app_windows_[app_window->session_id().id()] = std::move(controller);
 }
 
diff --git a/chromium/chrome/browser/extensions/api/terminal/terminal_private_api.cc b/chromium/chrome/browser/extensions/api/terminal/terminal_private_api.cc
index 582571ef429..ee44ebfbdde 100644
--- a/chromium/chrome/browser/extensions/api/terminal/terminal_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/terminal/terminal_private_api.cc
@@ -4,12 +4,12 @@
 
 #include "chrome/browser/extensions/api/terminal/terminal_private_api.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/values.h"
@@ -177,7 +177,7 @@ void TerminalPrivateOpenTerminalProcessFunction::RespondOnUIThread(
     Respond(Error("Failed to open process."));
     return;
   }
-  Respond(OneArgument(base::MakeUnique<base::Value>(terminal_id)));
+  Respond(OneArgument(std::make_unique<base::Value>(terminal_id)));
 }
 
 ExtensionFunction::ResponseAction TerminalPrivateSendInputFunction::Run() {
@@ -206,7 +206,7 @@ void TerminalPrivateSendInputFunction::SendInputOnRegistryTaskRunner(
 }
 
 void TerminalPrivateSendInputFunction::RespondOnUIThread(bool success) {
-  Respond(OneArgument(base::MakeUnique<base::Value>(success)));
+  Respond(OneArgument(std::make_unique<base::Value>(success)));
 }
 
 TerminalPrivateCloseTerminalProcessFunction::
@@ -241,7 +241,7 @@ void TerminalPrivateCloseTerminalProcessFunction::CloseOnRegistryTaskRunner(
 
 void TerminalPrivateCloseTerminalProcessFunction::RespondOnUIThread(
     bool success) {
-  Respond(OneArgument(base::MakeUnique<base::Value>(success)));
+  Respond(OneArgument(std::make_unique<base::Value>(success)));
 }
 
 TerminalPrivateOnTerminalResizeFunction::
@@ -278,7 +278,7 @@ void TerminalPrivateOnTerminalResizeFunction::OnResizeOnRegistryTaskRunner(
 }
 
 void TerminalPrivateOnTerminalResizeFunction::RespondOnUIThread(bool success) {
-  Respond(OneArgument(base::MakeUnique<base::Value>(success)));
+  Respond(OneArgument(std::make_unique<base::Value>(success)));
 }
 
 TerminalPrivateAckOutputFunction::~TerminalPrivateAckOutputFunction() {}
diff --git a/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc b/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc
index e49ad90f522..c52172b6396 100644
--- a/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc
+++ b/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc
@@ -6,8 +6,9 @@
 
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 
+#include <memory>
+
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_constants.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h"
@@ -479,7 +480,7 @@ ExtensionFunction::ResponseAction WebNavigationGetFrameFunction::Run() {
                                     include_incognito(), nullptr, nullptr,
                                     &web_contents, nullptr) ||
       !web_contents) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>()));
+    return RespondNow(OneArgument(std::make_unique<base::Value>()));
   }
 
   WebNavigationTabObserver* observer =
@@ -493,11 +494,11 @@ ExtensionFunction::ResponseAction WebNavigationGetFrameFunction::Run() {
       ExtensionApiFrameIdMap::Get()->GetRenderFrameHostById(web_contents,
                                                             frame_id);
   if (!frame_navigation_state.IsValidFrame(render_frame_host))
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>()));
+    return RespondNow(OneArgument(std::make_unique<base::Value>()));
 
   GURL frame_url = frame_navigation_state.GetUrl(render_frame_host);
   if (!frame_navigation_state.IsValidUrl(frame_url))
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>()));
+    return RespondNow(OneArgument(std::make_unique<base::Value>()));
 
   GetFrame::Results::Details frame_details;
   frame_details.url = frame_url.spec();
@@ -519,7 +520,7 @@ ExtensionFunction::ResponseAction WebNavigationGetAllFramesFunction::Run() {
                                     include_incognito(), nullptr, nullptr,
                                     &web_contents, nullptr) ||
       !web_contents) {
-    return RespondNow(OneArgument(base::MakeUnique<base::Value>()));
+    return RespondNow(OneArgument(std::make_unique<base::Value>()));
   }
 
   WebNavigationTabObserver* observer =
diff --git a/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc b/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc
index 42d255fb71e..b62518417f6 100644
--- a/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc
@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "base/json/json_writer.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
@@ -78,7 +77,7 @@ std::unique_ptr<Event> CreateOnBeforeNavigateEvent(
       ExtensionApiFrameIdMap::GetParentFrameId(navigation_handle);
   details.time_stamp = MilliSecondsFromTime(base::Time::Now());
 
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::WEB_NAVIGATION_ON_BEFORE_NAVIGATE,
       web_navigation::OnBeforeNavigate::kEventName,
       web_navigation::OnBeforeNavigate::Create(details),
@@ -123,7 +122,7 @@ void DispatchOnCommitted(events::HistogramValue histogram_value,
                                    ui::PAGE_TRANSITION_AUTO_TOPLEVEL))
     transition_type_string = "start_page";
   dict->SetString(keys::kTransitionTypeKey, transition_type_string);
-  auto qualifiers = base::MakeUnique<base::ListValue>();
+  auto qualifiers = std::make_unique<base::ListValue>();
   if (transition_type & ui::PAGE_TRANSITION_CLIENT_REDIRECT)
     qualifiers->AppendString("client_redirect");
   if (transition_type & ui::PAGE_TRANSITION_SERVER_REDIRECT)
@@ -138,7 +137,7 @@ void DispatchOnCommitted(events::HistogramValue histogram_value,
 
   content::BrowserContext* browser_context =
       navigation_handle->GetWebContents()->GetBrowserContext();
-  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+  auto event = std::make_unique<Event>(histogram_value, event_name,
                                        std::move(args), browser_context);
   DispatchEvent(browser_context, std::move(event), url);
 }
@@ -155,7 +154,7 @@ void DispatchOnDOMContentLoaded(content::WebContents* web_contents,
   details.time_stamp = MilliSecondsFromTime(base::Time::Now());
 
   content::BrowserContext* browser_context = web_contents->GetBrowserContext();
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::WEB_NAVIGATION_ON_DOM_CONTENT_LOADED,
       web_navigation::OnDOMContentLoaded::kEventName,
       web_navigation::OnDOMContentLoaded::Create(details), browser_context);
@@ -174,7 +173,7 @@ void DispatchOnCompleted(content::WebContents* web_contents,
   details.time_stamp = MilliSecondsFromTime(base::Time::Now());
 
   content::BrowserContext* browser_context = web_contents->GetBrowserContext();
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::WEB_NAVIGATION_ON_COMPLETED,
       web_navigation::OnCompleted::kEventName,
       web_navigation::OnCompleted::Create(details), browser_context);
@@ -204,7 +203,7 @@ void DispatchOnCreatedNavigationTarget(
   details.tab_id = ExtensionTabUtil::GetTabId(target_web_contents);
   details.time_stamp = MilliSecondsFromTime(base::Time::Now());
 
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::WEB_NAVIGATION_ON_CREATED_NAVIGATION_TARGET,
       web_navigation::OnCreatedNavigationTarget::kEventName,
       web_navigation::OnCreatedNavigationTarget::Create(details),
@@ -233,7 +232,7 @@ void DispatchOnErrorOccurred(content::WebContents* web_contents,
 
   content::BrowserContext* browser_context = web_contents->GetBrowserContext();
   auto event =
-      base::MakeUnique<Event>(events::WEB_NAVIGATION_ON_ERROR_OCCURRED,
+      std::make_unique<Event>(events::WEB_NAVIGATION_ON_ERROR_OCCURRED,
                               web_navigation::OnErrorOccurred::kEventName,
                               web_navigation::OnErrorOccurred::Create(details),
                               web_contents->GetBrowserContext());
@@ -254,7 +253,7 @@ void DispatchOnErrorOccurred(content::NavigationHandle* navigation_handle) {
 
   content::BrowserContext* browser_context =
       navigation_handle->GetWebContents()->GetBrowserContext();
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::WEB_NAVIGATION_ON_ERROR_OCCURRED,
       web_navigation::OnErrorOccurred::kEventName,
       web_navigation::OnErrorOccurred::Create(details), browser_context);
@@ -271,7 +270,7 @@ void DispatchOnTabReplaced(
   details.tab_id = ExtensionTabUtil::GetTabId(new_web_contents);
   details.time_stamp = MilliSecondsFromTime(base::Time::Now());
 
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::WEB_NAVIGATION_ON_TAB_REPLACED,
       web_navigation::OnTabReplaced::kEventName,
       web_navigation::OnTabReplaced::Create(details), browser_context);
diff --git a/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc b/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc
index da1fc213ac0..28dbc774e12 100644
--- a/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc
@@ -18,15 +18,12 @@
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_browser_main.h"
-#include "chrome/browser/chrome_browser_main_extra_parts.h"
-#include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/download_browsertest.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/loader/chrome_resource_dispatcher_host_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h"
 #include "chrome/browser/ui/browser.h"
@@ -39,8 +36,6 @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
-#include "content/public/browser/resource_dispatcher_host.h"
-#include "content/public/browser/resource_throttle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/context_menu_params.h"
@@ -65,107 +60,6 @@ namespace extensions {
 
 namespace {
 
-// This class can defer requests for arbitrary URLs.
-class TestNavigationListener
-    : public base::RefCountedThreadSafe<TestNavigationListener> {
- public:
-  TestNavigationListener() {}
-
-  // Add |url| to the set of URLs we should delay.
-  void DelayRequestsForURL(const GURL& url) {
-    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO, FROM_HERE,
-          base::BindOnce(&TestNavigationListener::DelayRequestsForURL, this,
-                         url));
-      return;
-    }
-    urls_to_delay_.insert(url);
-  }
-
-  // Resume all deferred requests.
-  void ResumeAll() {
-    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO, FROM_HERE,
-          base::BindOnce(&TestNavigationListener::ResumeAll, this));
-      return;
-    }
-    WeakThrottleList::const_iterator it;
-    for (it = throttles_.begin(); it != throttles_.end(); ++it) {
-      if (it->get())
-        (*it)->ResumeHandler();
-    }
-    throttles_.clear();
-  }
-
-  // Resume a specific request.
-  void Resume(const GURL& url) {
-    if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::IO, FROM_HERE,
-          base::BindOnce(&TestNavigationListener::Resume, this, url));
-      return;
-    }
-    WeakThrottleList::iterator it;
-    for (it = throttles_.begin(); it != throttles_.end(); ++it) {
-      if (it->get() && it->get()->url() == url) {
-        (*it)->ResumeHandler();
-        throttles_.erase(it);
-        break;
-      }
-    }
-  }
-
-  // Constructs a ResourceThrottle if the request for |url| should be held.
-  //
-  // Needs to be invoked on the IO thread.
-  std::unique_ptr<content::ResourceThrottle> CreateResourceThrottle(
-      const GURL& url) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    if (urls_to_delay_.find(url) == urls_to_delay_.end())
-      return NULL;
-
-    auto throttle = base::MakeUnique<Throttle>();
-    throttle->set_url(url);
-    throttles_.push_back(throttle->AsWeakPtr());
-    return std::move(throttle);
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<TestNavigationListener>;
-
-  virtual ~TestNavigationListener() {}
-
-  // Stores a throttle per URL request that we have delayed.
-  class Throttle : public content::ResourceThrottle,
-                   public base::SupportsWeakPtr<Throttle> {
-   public:
-    void ResumeHandler() { Resume(); }
-
-    // content::ResourceThrottle implementation.
-    void WillStartRequest(bool* defer) override { *defer = true; }
-
-    const char* GetNameForLogging() const override {
-      return "TestNavigationListener::Throttle";
-    }
-
-    void set_url(const GURL& url) { url_ = url; }
-    const GURL& url() { return url_; }
-
-   private:
-    GURL url_;
-  };
-  typedef base::WeakPtr<Throttle> WeakThrottle;
-  typedef std::list<WeakThrottle> WeakThrottleList;
-  WeakThrottleList throttles_;
-
-  // The set of URLs to be delayed.
-  std::set<GURL> urls_to_delay_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestNavigationListener);
-};
-
 // Waits for a WC to be created. Once it starts loading |delay_url| (after at
 // least the first navigation has committed), it delays the load, executes
 // |script| in the last committed RVH and resumes the load when a URL ending in
@@ -176,12 +70,10 @@ class DelayLoadStartAndExecuteJavascript
       public content::WebContentsObserver {
  public:
   DelayLoadStartAndExecuteJavascript(
-      TestNavigationListener* test_navigation_listener,
       const GURL& delay_url,
       const std::string& script,
       const std::string& until_url_suffix)
       : content::WebContentsObserver(),
-        test_navigation_listener_(test_navigation_listener),
         delay_url_(delay_url),
         until_url_suffix_(until_url_suffix),
         script_(script),
@@ -191,7 +83,6 @@ class DelayLoadStartAndExecuteJavascript
     registrar_.Add(this,
                    chrome::NOTIFICATION_TAB_ADDED,
                    content::NotificationService::AllSources());
-    test_navigation_listener_->DelayRequestsForURL(delay_url_);
   }
   ~DelayLoadStartAndExecuteJavascript() override {}
 
@@ -212,6 +103,11 @@ class DelayLoadStartAndExecuteJavascript
     if (navigation_handle->GetURL() != delay_url_ || !rfh_)
       return;
 
+    auto throttle =
+        std::make_unique<WillStartRequestObserverThrottle>(navigation_handle);
+    throttle_ = throttle->AsWeakPtr();
+    navigation_handle->RegisterThrottleForTesting(std::move(throttle));
+
     if (has_user_gesture_) {
       rfh_->ExecuteJavaScriptWithUserGestureForTests(
           base::UTF8ToUTF16(script_));
@@ -230,7 +126,8 @@ class DelayLoadStartAndExecuteJavascript
         base::EndsWith(navigation_handle->GetURL().spec(), until_url_suffix_,
                        base::CompareCase::SENSITIVE)) {
       content::WebContentsObserver::Observe(NULL);
-      test_navigation_listener_->ResumeAll();
+      if (throttle_)
+        throttle_->Unblock();
     }
 
     if (navigation_handle->IsInMainFrame())
@@ -242,9 +139,35 @@ class DelayLoadStartAndExecuteJavascript
   }
 
  private:
+  class WillStartRequestObserverThrottle
+      : public content::NavigationThrottle,
+        public base::SupportsWeakPtr<WillStartRequestObserverThrottle> {
+   public:
+    WillStartRequestObserverThrottle(content::NavigationHandle* handle)
+        : NavigationThrottle(handle) {}
+    ~WillStartRequestObserverThrottle() override {}
+
+    const char* GetNameForLogging() override {
+      return "WillStartRequestObserverThrottle";
+    }
+
+    void Unblock() {
+      DCHECK(throttled_);
+      Resume();
+    }
+
+   private:
+    NavigationThrottle::ThrottleCheckResult WillStartRequest() override {
+      throttled_ = true;
+      return NavigationThrottle::DEFER;
+    }
+
+    bool throttled_ = false;
+  };
+
   content::NotificationRegistrar registrar_;
 
-  scoped_refptr<TestNavigationListener> test_navigation_listener_;
+  base::WeakPtr<WillStartRequestObserverThrottle> throttle_;
 
   GURL delay_url_;
   std::string until_url_suffix_;
@@ -256,76 +179,6 @@ class DelayLoadStartAndExecuteJavascript
   DISALLOW_COPY_AND_ASSIGN(DelayLoadStartAndExecuteJavascript);
 };
 
-class StartProvisionalLoadObserver : public content::WebContentsObserver {
- public:
-  StartProvisionalLoadObserver(WebContents* web_contents,
-                               const GURL& expected_url)
-      : content::WebContentsObserver(web_contents),
-        url_(expected_url),
-        url_seen_(false),
-        message_loop_runner_(new content::MessageLoopRunner) {}
-  ~StartProvisionalLoadObserver() override {}
-
-  void DidStartNavigation(
-      content::NavigationHandle* navigation_handle) override {
-    if (navigation_handle->GetURL() == url_) {
-      url_seen_ = true;
-      message_loop_runner_->Quit();
-    }
-  }
-
-  // Run a nested run loop until navigation to the expected URL has started.
-  void Wait() {
-    if (url_seen_)
-      return;
-
-    message_loop_runner_->Run();
-  }
-
- private:
-  GURL url_;
-  bool url_seen_;
-
-  // The MessageLoopRunner used to spin the message loop during Wait().
-  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(StartProvisionalLoadObserver);
-};
-
-// A ResourceDispatcherHostDelegate that adds a TestNavigationObserver.
-class TestResourceDispatcherHostDelegate
-    : public ChromeResourceDispatcherHostDelegate {
- public:
-  explicit TestResourceDispatcherHostDelegate(
-      TestNavigationListener* test_navigation_listener)
-      : test_navigation_listener_(test_navigation_listener) {
-  }
-  ~TestResourceDispatcherHostDelegate() override {}
-
-  void RequestBeginning(net::URLRequest* request,
-                        content::ResourceContext* resource_context,
-                        content::AppCacheService* appcache_service,
-                        ResourceType resource_type,
-                        std::vector<std::unique_ptr<content::ResourceThrottle>>*
-                            throttles) override {
-    ChromeResourceDispatcherHostDelegate::RequestBeginning(
-        request,
-        resource_context,
-        appcache_service,
-        resource_type,
-        throttles);
-    std::unique_ptr<content::ResourceThrottle> throttle =
-        test_navigation_listener_->CreateResourceThrottle(request->url());
-    if (throttle)
-      throttles->push_back(std::move(throttle));
-  }
-
- private:
-  scoped_refptr<TestNavigationListener> test_navigation_listener_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate);
-};
-
 // Handles requests for URLs with paths of "/test*" sent to the test server, so
 // tests request a URL that receives a non-error response.
 std::unique_ptr<net::test_server::HttpResponse> HandleTestRequest(
@@ -361,25 +214,7 @@ class WebNavigationApiTest : public ExtensionApiTest {
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
-  void SetUpOnMainThread() override {
-    ExtensionApiTest::SetUpOnMainThread();
-    test_navigation_listener_ = new TestNavigationListener();
-    resource_dispatcher_host_delegate_.reset(
-        new TestResourceDispatcherHostDelegate(
-            test_navigation_listener_.get()));
-    content::ResourceDispatcherHost::Get()->SetDelegate(
-        resource_dispatcher_host_delegate_.get());
-  }
-
-  TestNavigationListener* test_navigation_listener() {
-    return test_navigation_listener_.get();
-  }
-
  private:
-  scoped_refptr<TestNavigationListener> test_navigation_listener_;
-  std::unique_ptr<TestResourceDispatcherHostDelegate>
-      resource_dispatcher_host_delegate_;
-
   DISALLOW_COPY_AND_ASSIGN(WebNavigationApiTest);
 };
 
@@ -404,20 +239,9 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, DISABLED_ServerRedirect) {
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, Download) {
-  base::ScopedAllowBlockingForTesting allow_blocking;
-  base::ScopedTempDir download_directory;
-  ASSERT_TRUE(download_directory.CreateUniqueTempDir());
-  DownloadPrefs* download_prefs =
-      DownloadPrefs::FromBrowserContext(browser()->profile());
-  download_prefs->SetDownloadPath(download_directory.GetPath());
-
-  DownloadTestObserverNotInProgress download_observer(
-      content::BrowserContext::GetDownloadManager(profile()), 1);
-  download_observer.StartObserving();
   ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/download"))
       << message_;
-  download_observer.WaitForFinished();
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ServerRedirectSingleProcess) {
@@ -587,7 +411,7 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, TargetBlank) {
   GURL url = embedded_test_server()->GetURL(
       "/extensions/api_test/webnavigation/targetBlank/a.html");
 
-  chrome::NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
+  NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
   ui_test_utils::NavigateToURL(&params);
 
   // There's a link with target=_blank on a.html. Click on it to open it in a
@@ -646,13 +470,11 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, CrossProcess) {
 
   // See crossProcess/d.html.
   DelayLoadStartAndExecuteJavascript call_script(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test1"),
       "navigate2()",
       "empty.html");
 
   DelayLoadStartAndExecuteJavascript call_script_user_gesture(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test2"),
       "navigate2()",
       "empty.html");
@@ -661,74 +483,18 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, CrossProcess) {
   ASSERT_TRUE(RunExtensionTest("webnavigation/crossProcess")) << message_;
 }
 
-// This test verifies proper events for the following navigation sequence:
-// * Site A commits
-// * Slow cross-site navigation to site B starts
-// * Slow same-site navigation to different page in site A starts
-// * The slow cross-site navigation commits, cancelling the slow same-site
-//   navigation
-// Slow navigations are simulated by deferring an URL request, which fires
-// an onBeforeNavigate event, but doesn't reach commit. The URL request can
-// later be resumed to allow it to commit and load.
-// This test cannot use DelayLoadStartAndExecuteJavascript, as that class
-// resumes all URL requests. Instead, the test explicitly delays each URL
-// and resumes manually at the required time.
-IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, CrossProcessAbort) {
-  // This test does not make sense in PlzNavigate mode, as simultanious
-  // navigations that make network requests are not supported.
-  if (content::IsBrowserSideNavigationEnabled())
-    return;
-
-  ASSERT_TRUE(StartEmbeddedTestServer());
-
-  // Add the cross-site URL delay early on, as loading the extension will
-  // cause the cross-site navigation to start.
-  GURL cross_site_url = embedded_test_server()->GetURL("/title1.html");
-  test_navigation_listener()->DelayRequestsForURL(cross_site_url);
-
-  // Load the extension manually, as its base URL is needed later on to
-  // construct a same-site URL to delay.
-  const Extension* extension =
-      LoadExtension(test_data_dir_.AppendASCII("webnavigation")
-                        .AppendASCII("crossProcessAbort"));
-
-  WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
-  ResultCatcher catcher;
-  StartProvisionalLoadObserver cross_site_load(tab, cross_site_url);
-
-  GURL same_site_url =
-      extension->GetResourceURL(extension->url(), "empty.html");
-  test_navigation_listener()->DelayRequestsForURL(same_site_url);
-  StartProvisionalLoadObserver same_site_load(tab, same_site_url);
-
-  // Ensure the cross-site navigation has started, then execute JavaScript
-  // to cause the renderer-initiated, non-user navigation.
-  cross_site_load.Wait();
-  tab->GetMainFrame()->ExecuteJavaScriptForTests(
-      base::UTF8ToUTF16("navigate2()"));
-
-  // Wait for the same-site navigation to start and resume the cross-site
-  // one, allowing it to commit.
-  same_site_load.Wait();
-  test_navigation_listener()->Resume(cross_site_url);
-
-  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
-}
-
 // crbug.com/708139.
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, DISABLED_CrossProcessFragment) {
   ASSERT_TRUE(StartEmbeddedTestServer());
 
   // See crossProcessFragment/f.html.
   DelayLoadStartAndExecuteJavascript call_script3(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test3"),
       "updateFragment()",
       base::StringPrintf("f.html?%u#foo", embedded_test_server()->port()));
 
   // See crossProcessFragment/g.html.
   DelayLoadStartAndExecuteJavascript call_script4(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test4"),
       "updateFragment()",
       base::StringPrintf("g.html?%u#foo", embedded_test_server()->port()));
@@ -743,21 +509,18 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, DISABLED_CrossProcessHistory) {
 
   // See crossProcessHistory/e.html.
   DelayLoadStartAndExecuteJavascript call_script2(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test2"),
       "updateHistory()",
       "empty.html");
 
   // See crossProcessHistory/h.html.
   DelayLoadStartAndExecuteJavascript call_script5(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test5"),
       "updateHistory()",
       "empty.html");
 
   // See crossProcessHistory/i.html.
   DelayLoadStartAndExecuteJavascript call_script6(
-      test_navigation_listener(),
       embedded_test_server()->GetURL("/test6"),
       "updateHistory()",
       "empty.html");
diff --git a/chromium/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc b/chromium/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
index 68940479485..dd86f9b6972 100644
--- a/chromium/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
@@ -59,8 +59,6 @@
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
-#include "net/log/net_log_with_source.h"
-#include "net/log/test_net_log.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_util.h"
@@ -133,7 +131,8 @@ bool HasWarning(const WarningSet& warnings,
 void GetPartOfMessageArguments(IPC::Message* message,
                                const base::DictionaryValue** out,
                                ExtensionMsg_DispatchEvent::Param* param) {
-  ASSERT_EQ(ExtensionMsg_DispatchEvent::ID, message->type());
+  ASSERT_EQ(static_cast<uint32_t>(ExtensionMsg_DispatchEvent::ID),
+            message->type());
   ASSERT_TRUE(ExtensionMsg_DispatchEvent::Read(message, param));
   const base::ListValue& list = std::get<1>(*param);
   ASSERT_EQ(1u, list.GetSize());
@@ -167,7 +166,8 @@ class TestIPCSender : public IPC::Sender {
  private:
   // IPC::Sender
   bool Send(IPC::Message* message) override {
-    EXPECT_EQ(ExtensionMsg_DispatchEvent::ID, message->type());
+    EXPECT_EQ(static_cast<uint32_t>(ExtensionMsg_DispatchEvent::ID),
+              message->type());
 
     EXPECT_FALSE(task_queue_.empty());
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
@@ -182,6 +182,29 @@ class TestIPCSender : public IPC::Sender {
   SentMessages sent_messages_;
 };
 
+class TestLogger : public WebRequestInfo::Logger {
+ public:
+  TestLogger() = default;
+  ~TestLogger() override = default;
+
+  size_t log_size() const { return events_.size(); }
+  void clear() { events_.clear(); }
+
+  // WebRequestInfo::Logger:
+  void LogEvent(net::NetLogEventType event_type,
+                const std::string& extension_id) override {
+    events_.push_back({event_type, extension_id});
+  }
+  void LogBlockedBy(const std::string& blocker_info) override {}
+  void LogUnblocked() override {}
+
+ private:
+  using Event = std::pair<net::NetLogEventType, std::string>;
+  std::vector<Event> events_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestLogger);
+};
+
 class ExtensionWebRequestTest : public testing::Test {
  public:
   ExtensionWebRequestTest()
@@ -534,14 +557,14 @@ void ExtensionWebRequestTest::FireURLRequestWithData(
                                          true /* overwrite */);
   }
   std::vector<std::unique_ptr<net::UploadElementReader>> element_readers;
-  element_readers.push_back(base::MakeUnique<net::UploadBytesElementReader>(
+  element_readers.push_back(std::make_unique<net::UploadBytesElementReader>(
       &(bytes_1[0]), bytes_1.size()));
-  element_readers.push_back(base::MakeUnique<net::UploadFileElementReader>(
+  element_readers.push_back(std::make_unique<net::UploadFileElementReader>(
       base::ThreadTaskRunnerHandle::Get().get(), base::FilePath(), 0, 0,
       base::Time()));
-  element_readers.push_back(base::MakeUnique<net::UploadBytesElementReader>(
+  element_readers.push_back(std::make_unique<net::UploadBytesElementReader>(
       &(bytes_2[0]), bytes_2.size()));
-  request->set_upload(base::MakeUnique<net::ElementsUploadDataStream>(
+  request->set_upload(std::make_unique<net::ElementsUploadDataStream>(
       std::move(element_readers), 0));
   ipc_sender_.PushTask(base::Bind(&base::DoNothing));
   request->Start();
@@ -613,7 +636,7 @@ TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) {
       Value::CreateWithCopiedBuffer(kPlainBlock1, kPlainBlock1Length), &raw);
   extensions::subtle::AppendKeyValuePair(
       keys::kRequestBodyRawFileKey,
-      base::MakeUnique<base::Value>(std::string()), &raw);
+      std::make_unique<base::Value>(std::string()), &raw);
   extensions::subtle::AppendKeyValuePair(
       keys::kRequestBodyRawBytesKey,
       Value::CreateWithCopiedBuffer(kPlainBlock2, kPlainBlock2Length), &raw);
@@ -1636,8 +1659,7 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeCancelOfResponses) {
   EventResponseDeltas deltas;
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   bool canceled = false;
 
   // Single event that does not cancel.
@@ -1645,9 +1667,9 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeCancelOfResponses) {
       new EventResponseDelta("extid1", base::Time::FromInternalValue(1000)));
   d1->cancel = false;
   deltas.push_back(d1);
-  MergeCancelOfResponses(deltas, &canceled, &net_log);
+  MergeCancelOfResponses(deltas, &canceled, &logger);
   EXPECT_FALSE(canceled);
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
 
   // Second event that cancels the request
   linked_ptr<EventResponseDelta> d2(
@@ -1655,15 +1677,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeCancelOfResponses) {
   d2->cancel = true;
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  MergeCancelOfResponses(deltas, &canceled, &net_log);
+  MergeCancelOfResponses(deltas, &canceled, &logger);
   EXPECT_TRUE(canceled);
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   EventResponseDeltas deltas;
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   GURL effective_new_url;
 
@@ -1672,7 +1693,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
       new EventResponseDelta("extid0", base::Time::FromInternalValue(0)));
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_TRUE(effective_new_url.is_empty());
 
   // Single redirect.
@@ -1682,12 +1703,12 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
 
   // Ignored redirect (due to precedence).
   GURL new_url_2("http://bar.com");
@@ -1697,13 +1718,13 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_EQ(2u, logger.log_size());
 
   // Overriding redirect.
   GURL new_url_3("http://baz.com");
@@ -1713,14 +1734,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_3, effective_new_url);
   EXPECT_EQ(2u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid1"));
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(3u, capturing_net_log.GetSize());
+  EXPECT_EQ(3u, logger.log_size());
 
   // Check that identical redirects don't cause a conflict.
   linked_ptr<EventResponseDelta> d4(
@@ -1729,22 +1750,21 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses) {
   deltas.push_back(d4);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_3, effective_new_url);
   EXPECT_EQ(2u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid1"));
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(4u, capturing_net_log.GetSize());
+  EXPECT_EQ(4u, logger.log_size());
 }
 
 // This tests that we can redirect to data:// urls, which is considered
 // a kind of cancelling requests.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   EventResponseDeltas deltas;
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   GURL effective_new_url;
 
@@ -1755,7 +1775,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_0, effective_new_url);
 
   // Cancel request by redirecting to a data:// URL. This shall override
@@ -1767,12 +1787,12 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
 
   // Cancel request by redirecting to the same data:// URL. This shall
   // not create any conflicts as it is in line with d1.
@@ -1783,12 +1803,13 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
+
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
-  EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_EQ(2u, logger.log_size());
 
   // Cancel redirect by redirecting to a different data:// URL. This needs
   // to create a conflict.
@@ -1799,21 +1820,20 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses2) {
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid3"));
-  EXPECT_EQ(3u, capturing_net_log.GetSize());
+  EXPECT_EQ(3u, logger.log_size());
 }
 
 // This tests that we can redirect to about:blank, which is considered
 // a kind of cancelling requests.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   EventResponseDeltas deltas;
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   GURL effective_new_url;
 
@@ -1824,7 +1844,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   d0->new_url = GURL(new_url_0);
   deltas.push_back(d0);
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_0, effective_new_url);
 
   // Cancel request by redirecting to about:blank. This shall override
@@ -1836,19 +1856,18 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses3) {
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   MergeOnBeforeRequestResponses(GURL(kExampleUrl), deltas, &effective_new_url,
-                                &warning_set, &net_log);
+                                &warning_set, &logger);
   EXPECT_EQ(new_url_1, effective_new_url);
   EXPECT_TRUE(warning_set.empty());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
 }
 
 // This tests that WebSocket requests can not be redirected.
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses4) {
   EventResponseDeltas deltas;
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   GURL effective_new_url;
 
@@ -1858,7 +1877,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeRequestResponses4) {
   delta->new_url = GURL("http://foo.com");
   deltas.push_back(delta);
   MergeOnBeforeRequestResponses(GURL("ws://example.com"), deltas,
-                                &effective_new_url, &warning_set, &net_log);
+                                &effective_new_url, &warning_set, &logger);
   EXPECT_EQ(GURL(), effective_new_url);
 }
 
@@ -1866,8 +1885,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   net::HttpRequestHeaders base_headers;
   base_headers.SetHeader("key1", "value 1");
   base_headers.SetHeader("key2", "value 2");
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
@@ -1879,14 +1897,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   bool request_headers_modified0;
   net::HttpRequestHeaders headers0;
   headers0.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers0, &warning_set, &net_log,
+  MergeOnBeforeSendHeadersResponses(deltas, &headers0, &warning_set, &logger,
                                     &request_headers_modified0);
   ASSERT_TRUE(headers0.GetHeader("key1", &header_value));
   EXPECT_EQ("value 1", header_value);
   ASSERT_TRUE(headers0.GetHeader("key2", &header_value));
   EXPECT_EQ("value 2", header_value);
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
   EXPECT_FALSE(request_headers_modified0);
 
   // Delete, modify and add a header.
@@ -1898,11 +1916,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   bool request_headers_modified1;
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log,
+  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &logger,
                                     &request_headers_modified1);
   EXPECT_FALSE(headers1.HasHeader("key1"));
   ASSERT_TRUE(headers1.GetHeader("key2", &header_value));
@@ -1910,7 +1928,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   ASSERT_TRUE(headers1.GetHeader("key3", &header_value));
   EXPECT_EQ("value 3", header_value);
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
   EXPECT_TRUE(request_headers_modified1);
 
   // Check that conflicts are atomic, i.e. if one header modification
@@ -1923,11 +1941,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   bool request_headers_modified2;
   net::HttpRequestHeaders headers2;
   headers2.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers2, &warning_set, &net_log,
+  MergeOnBeforeSendHeadersResponses(deltas, &headers2, &warning_set, &logger,
                                     &request_headers_modified2);
   EXPECT_FALSE(headers2.HasHeader("key1"));
   ASSERT_TRUE(headers2.GetHeader("key2", &header_value));
@@ -1937,7 +1955,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   EXPECT_FALSE(headers2.HasHeader("key4"));
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_EQ(2u, logger.log_size());
   EXPECT_TRUE(request_headers_modified2);
 
   // Check that identical modifications don't conflict and operations
@@ -1950,11 +1968,11 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   bool request_headers_modified3;
   net::HttpRequestHeaders headers3;
   headers3.MergeFrom(base_headers);
-  MergeOnBeforeSendHeadersResponses(deltas, &headers3, &warning_set, &net_log,
+  MergeOnBeforeSendHeadersResponses(deltas, &headers3, &warning_set, &logger,
                                     &request_headers_modified3);
   EXPECT_FALSE(headers3.HasHeader("key1"));
   ASSERT_TRUE(headers3.GetHeader("key2", &header_value));
@@ -1965,7 +1983,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnBeforeSendHeadersResponses) {
   EXPECT_EQ("value 5", header_value);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(3u, capturing_net_log.GetSize());
+  EXPECT_EQ(3u, logger.log_size());
   EXPECT_TRUE(request_headers_modified3);
 }
 
@@ -1974,8 +1992,7 @@ TEST(ExtensionWebRequestHelpersTest,
   net::HttpRequestHeaders base_headers;
   base_headers.AddHeaderFromString(
       "Cookie: name=value; name2=value2; name3=\"value3\"");
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
@@ -2023,13 +2040,13 @@ TEST(ExtensionWebRequestHelpersTest,
   net::HttpRequestHeaders headers1;
   headers1.MergeFrom(base_headers);
   warning_set.clear();
-  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &net_log,
+  MergeOnBeforeSendHeadersResponses(deltas, &headers1, &warning_set, &logger,
                                     &request_headers_modified1);
   EXPECT_TRUE(headers1.HasHeader("Cookie"));
   ASSERT_TRUE(headers1.GetHeader("Cookie", &header_value));
   EXPECT_EQ("name=new value; name2=new value; name4=\"value 4\"", header_value);
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
   EXPECT_FALSE(request_headers_modified1);
 }
 
@@ -2061,8 +2078,7 @@ std::string GetCookieExpirationDate(int delta_secs) {
 
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeCookiesInOnHeadersReceivedResponses) {
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
@@ -2098,10 +2114,10 @@ TEST(ExtensionWebRequestHelpersTest,
   deltas.push_back(d0);
   scoped_refptr<net::HttpResponseHeaders> new_headers0;
   MergeCookiesInOnHeadersReceivedResponses(
-        deltas, base_headers.get(), &new_headers0, &warning_set, &net_log);
+      deltas, base_headers.get(), &new_headers0, &warning_set, &logger);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
 
   linked_ptr<ResponseCookieModification> add_cookie =
       make_linked_ptr(new ResponseCookieModification);
@@ -2267,7 +2283,7 @@ TEST(ExtensionWebRequestHelpersTest,
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   warning_set.clear();
   MergeCookiesInOnHeadersReceivedResponses(
-      deltas, headers1.get(), &new_headers1, &warning_set, &net_log);
+      deltas, headers1.get(), &new_headers1, &warning_set, &logger);
 
   EXPECT_TRUE(new_headers1->HasHeader("Foo"));
   size_t iter = 0;
@@ -2292,12 +2308,11 @@ TEST(ExtensionWebRequestHelpersTest,
     actual_cookies.insert(cookie_string);
   EXPECT_EQ(expected_cookies, actual_cookies);
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
@@ -2321,12 +2336,12 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   GURL allowed_unsafe_redirect_url0;
   MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
                                   &new_headers0, &allowed_unsafe_redirect_url0,
-                                  &warning_set, &net_log,
+                                  &warning_set, &logger,
                                   &response_headers_modified0);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url0.is_empty());
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
   EXPECT_FALSE(response_headers_modified0);
 
   linked_ptr<EventResponseDelta> d1(
@@ -2337,13 +2352,13 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   bool response_headers_modified1;
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   GURL allowed_unsafe_redirect_url1;
   MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
                                   &new_headers1, &allowed_unsafe_redirect_url1,
-                                  &warning_set, &net_log,
+                                  &warning_set, &logger,
                                   &response_headers_modified1);
   ASSERT_TRUE(new_headers1.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url1.is_empty());
@@ -2358,7 +2373,7 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   }
   EXPECT_EQ(expected1, actual1);
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
   EXPECT_TRUE(response_headers_modified1);
 
   // Check that we replace response headers only once.
@@ -2371,13 +2386,13 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   bool response_headers_modified2;
   scoped_refptr<net::HttpResponseHeaders> new_headers2;
   GURL allowed_unsafe_redirect_url2;
   MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
                                   &new_headers2, &allowed_unsafe_redirect_url2,
-                                  &warning_set, &net_log,
+                                  &warning_set, &logger,
                                   &response_headers_modified2);
   ASSERT_TRUE(new_headers2.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url2.is_empty());
@@ -2389,15 +2404,14 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnHeadersReceivedResponses) {
   EXPECT_EQ(expected1, actual2);
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_EQ(2u, logger.log_size());
   EXPECT_TRUE(response_headers_modified2);
 }
 
 // Check that we do not delete too much
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnHeadersReceivedResponsesDeletion) {
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   std::string header_value;
   EventResponseDeltas deltas;
@@ -2423,7 +2437,7 @@ TEST(ExtensionWebRequestHelpersTest,
   GURL allowed_unsafe_redirect_url1;
   MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
                                   &new_headers1, &allowed_unsafe_redirect_url1,
-                                  &warning_set, &net_log,
+                                  &warning_set, &logger,
                                   &response_headers_modified1);
   ASSERT_TRUE(new_headers1.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url1.is_empty());
@@ -2440,7 +2454,7 @@ TEST(ExtensionWebRequestHelpersTest,
   }
   EXPECT_EQ(expected1, actual1);
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
   EXPECT_TRUE(response_headers_modified1);
 }
 
@@ -2450,8 +2464,7 @@ TEST(ExtensionWebRequestHelpersTest,
 TEST(ExtensionWebRequestHelpersTest,
      TestMergeOnHeadersReceivedResponsesRedirect) {
   EventResponseDeltas deltas;
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
 
   char base_headers_string[] =
@@ -2470,12 +2483,12 @@ TEST(ExtensionWebRequestHelpersTest,
   GURL allowed_unsafe_redirect_url0;
   MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
                                   &new_headers0, &allowed_unsafe_redirect_url0,
-                                  &warning_set, &net_log,
+                                  &warning_set, &logger,
                                   &response_headers_modified0);
   EXPECT_FALSE(new_headers0.get());
   EXPECT_TRUE(allowed_unsafe_redirect_url0.is_empty());
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
   EXPECT_FALSE(response_headers_modified0);
 
   // Single redirect.
@@ -2485,26 +2498,26 @@ TEST(ExtensionWebRequestHelpersTest,
   d1->new_url = GURL(new_url_1);
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
-  capturing_net_log.Clear();
+  logger.clear();
   bool response_headers_modified1;
+
   scoped_refptr<net::HttpResponseHeaders> new_headers1;
   GURL allowed_unsafe_redirect_url1;
   MergeOnHeadersReceivedResponses(GURL(kExampleUrl), deltas, base_headers.get(),
                                   &new_headers1, &allowed_unsafe_redirect_url1,
-                                  &warning_set, &net_log,
+                                  &warning_set, &logger,
                                   &response_headers_modified1);
 
   EXPECT_TRUE(new_headers1.get());
   EXPECT_TRUE(new_headers1->HasHeaderValue("Location", new_url_1.spec()));
   EXPECT_EQ(new_url_1, allowed_unsafe_redirect_url1);
   EXPECT_TRUE(warning_set.empty());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
   EXPECT_FALSE(response_headers_modified1);
 }
 
 TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
-  net::BoundTestNetLog capturing_net_log;
-  net::NetLogWithSource net_log = capturing_net_log.bound();
+  TestLogger logger;
   WarningSet warning_set;
   EventResponseDeltas deltas;
   base::string16 username = base::ASCIIToUTF16("foo");
@@ -2516,12 +2529,12 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
       new EventResponseDelta("extid0", base::Time::FromInternalValue(3000)));
   deltas.push_back(d0);
   net::AuthCredentials auth0;
-  bool credentials_set = MergeOnAuthRequiredResponses(
-      deltas, &auth0, &warning_set, &net_log);
+  bool credentials_set =
+      MergeOnAuthRequiredResponses(deltas, &auth0, &warning_set, &logger);
   EXPECT_FALSE(credentials_set);
   EXPECT_TRUE(auth0.Empty());
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(0u, capturing_net_log.GetSize());
+  EXPECT_EQ(0u, logger.log_size());
 
   // Check that we can set AuthCredentials.
   linked_ptr<EventResponseDelta> d1(
@@ -2530,16 +2543,16 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   deltas.push_back(d1);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   net::AuthCredentials auth1;
-  credentials_set = MergeOnAuthRequiredResponses(
-      deltas, &auth1, &warning_set, &net_log);
+  credentials_set =
+      MergeOnAuthRequiredResponses(deltas, &auth1, &warning_set, &logger);
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth1.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(0u, warning_set.size());
-  EXPECT_EQ(1u, capturing_net_log.GetSize());
+  EXPECT_EQ(1u, logger.log_size());
 
   // Check that we set AuthCredentials only once.
   linked_ptr<EventResponseDelta> d2(
@@ -2548,17 +2561,17 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   deltas.push_back(d2);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   net::AuthCredentials auth2;
-  credentials_set = MergeOnAuthRequiredResponses(
-      deltas, &auth2, &warning_set, &net_log);
+  credentials_set =
+      MergeOnAuthRequiredResponses(deltas, &auth2, &warning_set, &logger);
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth2.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(2u, capturing_net_log.GetSize());
+  EXPECT_EQ(2u, logger.log_size());
 
   // Check that we can set identical AuthCredentials twice without causing
   // a conflict.
@@ -2568,17 +2581,17 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   deltas.push_back(d3);
   deltas.sort(&InDecreasingExtensionInstallationTimeOrder);
   warning_set.clear();
-  capturing_net_log.Clear();
+  logger.clear();
   net::AuthCredentials auth3;
-  credentials_set = MergeOnAuthRequiredResponses(
-      deltas, &auth3, &warning_set, &net_log);
+  credentials_set =
+      MergeOnAuthRequiredResponses(deltas, &auth3, &warning_set, &logger);
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
-  EXPECT_EQ(3u, capturing_net_log.GetSize());
+  EXPECT_EQ(3u, logger.log_size());
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/web_request/web_request_apitest.cc b/chromium/chrome/browser/extensions/api/web_request/web_request_apitest.cc
index 533b25b9fa3..e0b875c7d40 100644
--- a/chromium/chrome/browser/extensions/api/web_request/web_request_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/web_request/web_request_apitest.cc
@@ -2,12 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -19,6 +22,8 @@
 #include "chrome/browser/extensions/extension_with_management_policy_apitest.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
+#include "chrome/browser/net/profile_network_context_service.h"
+#include "chrome/browser/net/profile_network_context_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/browser.h"
@@ -26,10 +31,12 @@
 #include "chrome/browser/ui/login/login_handler.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/test/base/search_test_utils.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chromeos/login/scoped_test_public_session_login_state.h"
+#include "components/prefs/pref_service.h"
+#include "components/proxy_config/proxy_config_dictionary.h"
+#include "components/proxy_config/proxy_config_pref_names.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
@@ -251,8 +258,8 @@ void TearDownDevToolsFrontendInterceptorOnIO() {
 
 class ExtensionWebRequestApiTest : public ExtensionApiTest {
  public:
-  void SetUpInProcessBrowserTestFixture() override {
-    ExtensionApiTest::SetUpInProcessBrowserTestFixture();
+  void SetUpOnMainThread() override {
+    ExtensionApiTest::SetUpOnMainThread();
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
@@ -750,7 +757,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
   ASSERT_TRUE(embedded_test_server()->Start());
 
   // Load an extension that registers a listener for webRequest events, and
-  // wait 'til it's initialized.
+  // wait until it's initialized.
   ExtensionTestMessageListener listener("ready", false);
   const Extension* extension =
       LoadExtension(test_data_dir_.AppendASCII("webrequest_activetab"));
@@ -760,7 +767,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
   // Navigate the browser to a page in a new tab.
   const std::string kHost = "a.com";
   GURL url = embedded_test_server()->GetURL(kHost, "/iframe_cross_site.html");
-  chrome::NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
+  NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
   params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   ui_test_utils::NavigateToURL(&params);
 
@@ -853,7 +860,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
   int port = embedded_test_server()->port();
 
   // Load an extension that registers a listener for webRequest events, and
-  // wait 'til it's initialized.
+  // wait until it's initialized.
   ExtensionTestMessageListener listener("ready", false);
   const Extension* extension = LoadExtension(
       test_data_dir_.AppendASCII("webrequest_clients_google_com"));
@@ -886,7 +893,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
                                     testcase.main_frame_url, port));
     }
 
-    chrome::NavigateParams params(browser(), url, ui::PAGE_TRANSITION_TYPED);
+    NavigateParams params(browser(), url, ui::PAGE_TRANSITION_TYPED);
     ui_test_utils::NavigateToURL(&params);
 
     EXPECT_EQ(expected_requests_observed,
@@ -952,6 +959,53 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
             GetWebRequestCountFromBackgroundPage(extension, profile()));
 }
 
+// Verify that requests for PAC scripts are protected properly.
+IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
+                       WebRequestPacRequestProtection) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Load an extension that registers a listener for webRequest events, and
+  // wait until it's initialized.
+  ExtensionTestMessageListener listener("ready", false);
+  const Extension* extension =
+      LoadExtension(test_data_dir_.AppendASCII("webrequest_pac_request"));
+  ASSERT_TRUE(extension) << message_;
+  EXPECT_TRUE(listener.WaitUntilSatisfied());
+
+  // Configure a PAC script. Need to do this after the extension is loaded, so
+  // that the PAC isn't already loaded by the time the extension starts
+  // affecting requests.
+  PrefService* pref_service = browser()->profile()->GetPrefs();
+  pref_service->Set(proxy_config::prefs::kProxy,
+                    *ProxyConfigDictionary::CreatePacScript(
+                        embedded_test_server()->GetURL("/self.pac").spec(),
+                        true /* pac_mandatory */));
+  // Flush the proxy configuration change over the Mojo pipe to avoid any races.
+  ProfileNetworkContextServiceFactory::GetForContext(browser()->profile())
+      ->FlushProxyConfigMonitorForTesting();
+
+  // Navigate to a page. The URL doesn't matter.
+  ui_test_utils::NavigateToURL(browser(),
+                               embedded_test_server()->GetURL("/title2.html"));
+
+  // The extension should not have seen the PAC request.
+  EXPECT_EQ(0, GetCountFromBackgroundPage(extension, profile(),
+                                          "window.pacRequestCount"));
+
+  // The extension should have seen the request for the main frame.
+  EXPECT_EQ(1, GetCountFromBackgroundPage(extension, profile(),
+                                          "window.title2RequestCount"));
+
+  // The PAC request should have succeeded, as should the subsequent URL
+  // request.
+  EXPECT_EQ(content::PAGE_TYPE_NORMAL, browser()
+                                           ->tab_strip_model()
+                                           ->GetActiveWebContents()
+                                           ->GetController()
+                                           .GetLastCommittedEntry()
+                                           ->GetPageType());
+}
+
 // Checks that the Dice response header is protected for Gaia URLs, but not
 // other URLs.
 IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
@@ -1404,7 +1458,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTestWithManagementPolicy,
 
   // Navigate the browser to a page in a new tab.
   GURL url = embedded_test_server()->GetURL(protected_domain, "/empty.html");
-  chrome::NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
+  NavigateParams params(browser(), url, ui::PAGE_TRANSITION_LINK);
   params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   ui_test_utils::NavigateToURL(&params);
 
diff --git a/chromium/chrome/browser/extensions/api/web_request/web_request_event_details_unittest.cc b/chromium/chrome/browser/extensions/api/web_request/web_request_event_details_unittest.cc
index 8c727c6d624..63bbb3cca2f 100644
--- a/chromium/chrome/browser/extensions/api/web_request/web_request_event_details_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/web_request/web_request_event_details_unittest.cc
@@ -92,8 +92,9 @@ TEST(WebRequestEventDetailsTest, SetResponseHeaders) {
     std::unique_ptr<net::URLRequest> request = context.CreateRequest(
         GURL("http://www.example.com"), net::DEFAULT_PRIORITY, nullptr,
         TRAFFIC_ANNOTATION_FOR_TESTS);
-    WebRequestEventDetails details(request.get(), kFilter);
-    details.SetResponseHeaders(request.get(), headers.get());
+    WebRequestInfo request_info(request.get());
+    WebRequestEventDetails details(request_info, kFilter);
+    details.SetResponseHeaders(request_info, headers.get());
     std::unique_ptr<base::DictionaryValue> dict =
         details.GetFilteredDict(kFilter, nullptr, std::string(), false);
     base::Value* filtered_headers = dict->FindKey("responseHeaders");
@@ -114,8 +115,9 @@ TEST(WebRequestEventDetailsTest, SetResponseHeaders) {
     std::unique_ptr<net::URLRequest> gaia_request = context.CreateRequest(
         GaiaUrls::GetInstance()->gaia_url(), net::DEFAULT_PRIORITY, nullptr,
         TRAFFIC_ANNOTATION_FOR_TESTS);
-    WebRequestEventDetails gaia_details(gaia_request.get(), kFilter);
-    gaia_details.SetResponseHeaders(gaia_request.get(), headers.get());
+    WebRequestInfo gaia_request_info(gaia_request.get());
+    WebRequestEventDetails gaia_details(gaia_request_info, kFilter);
+    gaia_details.SetResponseHeaders(gaia_request_info, headers.get());
     std::unique_ptr<base::DictionaryValue> dict =
         gaia_details.GetFilteredDict(kFilter, nullptr, std::string(), false);
     base::Value* filtered_headers = dict->FindKey("responseHeaders");
diff --git a/chromium/chrome/browser/extensions/api/web_request/web_request_permissions_unittest.cc b/chromium/chrome/browser/extensions/api/web_request/web_request_permissions_unittest.cc
index aa1e24f38c1..8bcd3345fe3 100644
--- a/chromium/chrome/browser/extensions/api/web_request/web_request_permissions_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/web_request/web_request_permissions_unittest.cc
@@ -13,6 +13,7 @@
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/previews_state.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "extensions/browser/api/web_request/web_request_info.h"
 #include "extensions/browser/api/web_request/web_request_permissions.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/common/constants.h"
@@ -129,9 +130,10 @@ TEST_F(ExtensionWebRequestHelpersTestWithThreadsTest, TestHideRequestForURL) {
     std::unique_ptr<net::URLRequest> request(
         context.CreateRequest(sensitive_url, net::DEFAULT_PRIORITY, NULL,
                               TRAFFIC_ANNOTATION_FOR_TESTS));
-    EXPECT_TRUE(WebRequestPermissions::HideRequest(
-        extension_info_map_.get(), request.get(), nullptr)) <<
-        sensitive_urls[i];
+    extensions::WebRequestInfo request_info(request.get());
+    EXPECT_TRUE(WebRequestPermissions::HideRequest(extension_info_map_.get(),
+                                                   request_info))
+        << sensitive_urls[i];
   }
   // Check that requests are accepted if they don't touch sensitive urls.
   for (size_t i = 0; i < arraysize(non_sensitive_urls); ++i) {
@@ -139,9 +141,10 @@ TEST_F(ExtensionWebRequestHelpersTestWithThreadsTest, TestHideRequestForURL) {
     std::unique_ptr<net::URLRequest> request(
         context.CreateRequest(non_sensitive_url, net::DEFAULT_PRIORITY, NULL,
                               TRAFFIC_ANNOTATION_FOR_TESTS));
-    EXPECT_FALSE(WebRequestPermissions::HideRequest(
-        extension_info_map_.get(), request.get(), nullptr)) <<
-        non_sensitive_urls[i];
+    extensions::WebRequestInfo request_info(request.get());
+    EXPECT_FALSE(WebRequestPermissions::HideRequest(extension_info_map_.get(),
+                                                    request_info))
+        << non_sensitive_urls[i];
   }
 
   // Check protection of requests originating from the frame showing the Chrome
@@ -151,8 +154,10 @@ TEST_F(ExtensionWebRequestHelpersTestWithThreadsTest, TestHideRequestForURL) {
   std::unique_ptr<net::URLRequest> non_sensitive_request(
       context.CreateRequest(non_sensitive_url, net::DEFAULT_PRIORITY, NULL,
                             TRAFFIC_ANNOTATION_FOR_TESTS));
-  EXPECT_FALSE(WebRequestPermissions::HideRequest(
-      extension_info_map_.get(), non_sensitive_request.get(), nullptr));
+  extensions::WebRequestInfo non_sensitive_request_info(
+      non_sensitive_request.get());
+  EXPECT_FALSE(WebRequestPermissions::HideRequest(extension_info_map_.get(),
+                                                  non_sensitive_request_info));
   // If the origin is labeled by the WebStoreAppId, it becomes protected.
   {
     int process_id = 42;
@@ -170,9 +175,20 @@ TEST_F(ExtensionWebRequestHelpersTestWithThreadsTest, TestHideRequestForURL) {
         /*navigation_ui_data*/ nullptr);
     extension_info_map_->RegisterExtensionProcess(extensions::kWebStoreAppId,
                                                   process_id, site_instance_id);
-    EXPECT_TRUE(WebRequestPermissions::HideRequest(
-        extension_info_map_.get(), sensitive_request.get(), nullptr));
+    extensions::WebRequestInfo sensitive_request_info(sensitive_request.get());
+    EXPECT_TRUE(WebRequestPermissions::HideRequest(extension_info_map_.get(),
+                                                   sensitive_request_info));
   }
+
+  // Check that requests are for a non-sensitive URL is rejected if it's a PAC
+  // script fetch.
+  std::unique_ptr<net::URLRequest> request(
+      context.CreateRequest(non_sensitive_url, net::DEFAULT_PRIORITY, NULL,
+                            TRAFFIC_ANNOTATION_FOR_TESTS));
+  request->set_is_pac_request(true);
+  extensions::WebRequestInfo request_info(request.get());
+  EXPECT_TRUE(WebRequestPermissions::HideRequest(extension_info_map_.get(),
+                                                 request_info));
 }
 
 TEST_F(ExtensionWebRequestHelpersTestWithThreadsTest,
diff --git a/chromium/chrome/browser/extensions/api/web_view/OWNERS b/chromium/chrome/browser/extensions/api/web_view/OWNERS
index a25b3ecc1bb..74d34105399 100644
--- a/chromium/chrome/browser/extensions/api/web_view/OWNERS
+++ b/chromium/chrome/browser/extensions/api/web_view/OWNERS
@@ -1,6 +1,3 @@
-fsamuel@chromium.org
-lazyboy@chromium.org
-wjmaclean@chromium.org
-paulmeyer@chromium.org
+file://components/guest_view/OWNERS
 
 # COMPONENT: Platform>Apps>BrowserTag
diff --git a/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc b/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc
index 49eaae2b246..fa1e2bdda32 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc
@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "base/lazy_instance.h"
-#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
@@ -93,9 +92,9 @@ void WebrtcAudioPrivateEventService::SignalEvent() {
     const std::string& extension_id = extension->id();
     if (router->ExtensionHasEventListener(extension_id, kEventName) &&
         extension->permissions_data()->HasAPIPermission("webrtcAudioPrivate")) {
-      std::unique_ptr<Event> event = base::MakeUnique<Event>(
+      std::unique_ptr<Event> event = std::make_unique<Event>(
           events::WEBRTC_AUDIO_PRIVATE_ON_SINKS_CHANGED, kEventName,
-          base::MakeUnique<base::ListValue>());
+          std::make_unique<base::ListValue>());
       router->DispatchEventToExtension(extension_id, std::move(event));
     }
   }
@@ -198,7 +197,7 @@ void WebrtcAudioPrivateGetSinksFunction::
     ReceiveOutputDeviceDescriptionsOnIOThread(
         media::AudioDeviceDescriptions sink_devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  auto results = base::MakeUnique<SinkInfoVector>();
+  auto results = std::make_unique<SinkInfoVector>();
   for (const media::AudioDeviceDescription& description : sink_devices) {
     wap::SinkInfo info;
     info.sink_id = CalculateHMAC(description.unique_id);
@@ -281,13 +280,15 @@ void WebrtcAudioPrivateGetAssociatedSinkFunction::
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::CalculateHMACOnIOThread(
-    const std::string& raw_sink_id) {
+    const base::Optional<std::string>& raw_sink_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!raw_sink_id || !raw_sink_id->empty());
+  // If no |raw_sink_id| is provided, the default device is used.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &WebrtcAudioPrivateGetAssociatedSinkFunction::ReceiveHMACOnUIThread,
-          this, CalculateHMAC(raw_sink_id)));
+          this, CalculateHMAC(raw_sink_id.value_or(std::string()))));
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::ReceiveHMACOnUIThread(
diff --git a/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h b/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h
index 2d706be3b2d..9f022383542 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h
+++ b/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h
@@ -135,7 +135,7 @@ class WebrtcAudioPrivateGetAssociatedSinkFunction
 
   // IO thread: Receives the raw sink ID, calculates HMAC and replies to IO
   // thread with ReceiveHMACOnUIThread().
-  void CalculateHMACOnIOThread(const std::string& raw_sink_id);
+  void CalculateHMACOnIOThread(const base::Optional<std::string>& raw_sink_id);
 
   // Receives the associated sink ID as HMAC and sends the response.
   void ReceiveHMACOnUIThread(const std::string& hmac);
diff --git a/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc b/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
index b32922914e0..b09a14d684f 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
@@ -36,6 +36,7 @@
 #include "extensions/common/permissions/permissions_data.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_system.h"
+#include "media/base/media_switches.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -233,6 +234,13 @@ class HangoutServicesBrowserTest : public AudioWaitingExtensionTest {
     ComponentLoader::EnableBackgroundExtensionsForTesting();
     AudioWaitingExtensionTest::SetUp();
   }
+
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    AudioWaitingExtensionTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitchASCII(
+        switches::kAutoplayPolicy,
+        switches::autoplay::kNoUserGestureRequiredPolicy);
+  }
 };
 
 #if BUILDFLAG(ENABLE_HANGOUT_SERVICES_EXTENSION)
diff --git a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_event_log_apitest.cc b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_event_log_apitest.cc
deleted file mode 100644
index 4a8f8d6a78a..00000000000
--- a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_event_log_apitest.cc
+++ /dev/null
@@ -1,321 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <memory>
-#include <utility>
-
-#include "base/command_line.h"
-#include "base/files/file_path_watcher.h"
-#include "base/json/json_writer.h"
-#include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_restrictions.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-#include "chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h"
-#include "chrome/browser/extensions/extension_function_test_utils.h"
-#include "chrome/browser/extensions/extension_tab_util.h"
-#include "chrome/browser/media/webrtc/webrtc_browsertest_base.h"
-#include "chrome/browser/media/webrtc/webrtc_browsertest_common.h"
-#include "chrome/common/chrome_switches.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/common/content_switches.h"
-#include "content/public/test/browser_test_utils.h"
-#include "extensions/browser/api_test_utils.h"
-#include "extensions/common/extension_builder.h"
-#include "media/base/media_switches.h"
-#include "net/test/embedded_test_server/embedded_test_server.h"
-
-#if defined(OS_WIN)
-#define IntToStringType base::IntToString16
-#else
-#define IntToStringType base::IntToString
-#endif
-
-using extensions::WebrtcLoggingPrivateStartWebRtcEventLoggingFunction;
-using extensions::WebrtcLoggingPrivateStopWebRtcEventLoggingFunction;
-
-namespace utils = extension_function_test_utils;
-
-namespace {
-
-// Get the expected EventLog file name. The name will be
-// <temporary path>.<render process id>.<peer connection id>, for example
-// /tmp/.org.chromium.Chromium.vsygNQ/dnFW8ch/Default/WebRTC
-// Logs/WebRtcEventLog.1.6.1
-base::FilePath GetExpectedEventLogFileName(const base::FilePath& base_file,
-                                           int render_process_id) {
-  static const int kExpectedPeerConnectionId = 1;
-  return base_file.AddExtension(IntToStringType(render_process_id))
-      .AddExtension(IntToStringType(kExpectedPeerConnectionId));
-}
-
-static const char kMainWebrtcTestHtmlPage[] = "/webrtc/webrtc_jsep01_test.html";
-
-std::string ParamsToString(const base::ListValue& parameters) {
-  std::string parameter_string;
-  EXPECT_TRUE(base::JSONWriter::Write(parameters, &parameter_string));
-  return parameter_string;
-}
-
-class FileWaiter : public base::RefCountedThreadSafe<FileWaiter> {
- public:
-  explicit FileWaiter(const base::FilePath& path)
-      : found_(false), path_(path) {}
-
-  bool Start() {
-    base::ScopedAllowBlockingForTesting allow_blocking;
-    if (base::PathExists(path_)) {
-      found_ = true;
-      return true;
-    } else {
-      return watcher_.Watch(path_, false /* recursive */,
-                            base::Bind(&FileWaiter::Callback, this));
-    }
-  }
-
-  // Returns true if |path_| became available.
-  bool WaitForFile() {
-    if (!found_) {
-      run_loop_.Run();
-    }
-    return found_;
-  }
-
-  // implements FilePathWatcher::Callback
-  void Callback(const base::FilePath& path, bool error) {
-    EXPECT_EQ(path, path_);
-    if (!error)
-      found_ = true;
-    run_loop_.Quit();
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<FileWaiter>;
-  ~FileWaiter() {}
-  base::RunLoop run_loop_;
-  bool found_;
-  base::FilePath path_;
-  base::FilePathWatcher watcher_;
-  DISALLOW_COPY_AND_ASSIGN(FileWaiter);
-};
-
-class WebrtcEventLogApiTest : public WebRtcTestBase {
- protected:
-  void SetUp() override {
-    WebRtcTestBase::SetUp();
-    extension_ = extensions::ExtensionBuilder("Test").Build();
-  }
-
-  void SetUpInProcessBrowserTestFixture() override {
-    DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
-  }
-
-  void SetUpCommandLine(base::CommandLine* command_line) override {
-    // Ensure the infobar is enabled, since we expect that in this test.
-    EXPECT_FALSE(command_line->HasSwitch(switches::kUseFakeUIForMediaStream));
-
-    // Always use fake devices.
-    command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream);
-
-    // Flag used by TestWebAudioMediaStream to force garbage collection.
-    command_line->AppendSwitchASCII(switches::kJavaScriptFlags, "--expose-gc");
-
-    // Enable the the event log in the extension API.
-    command_line->AppendSwitch(
-        switches::kEnableWebRtcEventLoggingFromExtension);
-  }
-
-  template <typename T>
-  scoped_refptr<T> CreateExtensionFunction() {
-    scoped_refptr<T> function(new T());
-    function->set_extension(extension_.get());
-    function->set_has_callback(true);
-    return function;
-  }
-
-  void AppendTabIdAndUrl(base::ListValue* parameters,
-                         content::WebContents* tab) {
-    std::unique_ptr<base::DictionaryValue> request_info(
-        new base::DictionaryValue());
-    request_info->SetInteger("tabId",
-                             extensions::ExtensionTabUtil::GetTabId(tab));
-    parameters->Append(std::move(request_info));
-    parameters->AppendString(tab->GetURL().GetOrigin().spec());
-  }
-
- private:
-  scoped_refptr<extensions::Extension> extension_;
-};
-
-}  // namespace
-
-IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest, TestStartStopWebRtcEventLogging) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  content::WebContents* left_tab =
-      OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
-  content::WebContents* right_tab =
-      OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
-
-  SetupPeerconnectionWithLocalStream(left_tab);
-  SetupPeerconnectionWithLocalStream(right_tab);
-
-  SetDefaultVideoCodec(left_tab, "VP8");
-  SetDefaultVideoCodec(right_tab, "VP8");
-  NegotiateCall(left_tab, right_tab);
-
-  StartDetectingVideo(left_tab, "remote-view");
-  StartDetectingVideo(right_tab, "remote-view");
-
-  // Start the event log.
-  const int seconds = 0;
-  base::ListValue start_params;
-  AppendTabIdAndUrl(&start_params, left_tab);
-  start_params.AppendInteger(seconds);
-  scoped_refptr<WebrtcLoggingPrivateStartWebRtcEventLoggingFunction>
-      start_function(CreateExtensionFunction<
-                     WebrtcLoggingPrivateStartWebRtcEventLoggingFunction>());
-  std::unique_ptr<base::Value> start_result(
-      utils::RunFunctionAndReturnSingleResult(
-          start_function.get(), ParamsToString(start_params), browser()));
-  ASSERT_TRUE(start_result.get());
-
-  // Get the file name.
-  std::unique_ptr<extensions::api::webrtc_logging_private::RecordingInfo>
-      recordings_info_start(
-          extensions::api::webrtc_logging_private::RecordingInfo::FromValue(
-              *start_result));
-  ASSERT_TRUE(recordings_info_start.get());
-  base::FilePath file_name_start(
-      base::FilePath::FromUTF8Unsafe(recordings_info_start->prefix_path));
-
-#if !defined(OS_MACOSX)
-  // Video is choppy on Mac OS X. http://crbug.com/443542.
-  WaitForVideoToPlay(left_tab);
-  WaitForVideoToPlay(right_tab);
-#endif
-
-  // Stop the event log.
-  base::ListValue stop_params;
-  AppendTabIdAndUrl(&stop_params, left_tab);
-  scoped_refptr<WebrtcLoggingPrivateStopWebRtcEventLoggingFunction>
-      stop_function(CreateExtensionFunction<
-                    WebrtcLoggingPrivateStopWebRtcEventLoggingFunction>());
-  std::unique_ptr<base::Value> stop_result(
-      utils::RunFunctionAndReturnSingleResult(
-          stop_function.get(), ParamsToString(stop_params), browser()));
-
-  // Get the file name.
-  std::unique_ptr<extensions::api::webrtc_logging_private::RecordingInfo>
-      recordings_info_stop(
-          extensions::api::webrtc_logging_private::RecordingInfo::FromValue(
-              *stop_result));
-  ASSERT_TRUE(recordings_info_stop.get());
-  base::FilePath file_name_stop(
-      base::FilePath::FromUTF8Unsafe(recordings_info_stop->prefix_path));
-
-  HangUp(left_tab);
-  HangUp(right_tab);
-
-  EXPECT_EQ(file_name_start, file_name_stop);
-
-  // Check that the file exists and is non-empty.
-  content::RenderProcessHost* render_process_host =
-      left_tab->GetMainFrame()->GetProcess();
-  ASSERT_NE(render_process_host, nullptr);
-  int render_process_id = render_process_host->GetID();
-  base::FilePath full_file_name =
-      GetExpectedEventLogFileName(file_name_stop, render_process_id);
-  int64_t file_size = 0;
-  scoped_refptr<FileWaiter> waiter = new FileWaiter(full_file_name);
-
-  ASSERT_TRUE(waiter->Start()) << "ERROR watching for "
-                               << full_file_name.value();
-  ASSERT_TRUE(waiter->WaitForFile());
-  base::ScopedAllowBlockingForTesting allow_blocking;
-  ASSERT_TRUE(base::PathExists(full_file_name));
-  EXPECT_TRUE(base::GetFileSize(full_file_name, &file_size));
-  EXPECT_GT(file_size, 0);
-
-  // Clean up.
-  base::DeleteFile(full_file_name, false);
-}
-
-IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest,
-                       TestStartTimedWebRtcEventLogging) {
-  base::ScopedAllowBlockingForTesting allow_blocking;
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  content::WebContents* left_tab =
-      OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
-  content::WebContents* right_tab =
-      OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
-
-  SetupPeerconnectionWithLocalStream(left_tab);
-  SetupPeerconnectionWithLocalStream(right_tab);
-
-  SetDefaultVideoCodec(left_tab, "VP8");
-  SetDefaultVideoCodec(right_tab, "VP8");
-  NegotiateCall(left_tab, right_tab);
-
-  StartDetectingVideo(left_tab, "remote-view");
-  StartDetectingVideo(right_tab, "remote-view");
-
-  // Start the event log. RunFunctionAndReturnSingleResult will block until a
-  // result is available, which happens when the logging stops after 1 second.
-  const int seconds = 1;
-  base::ListValue start_params;
-  AppendTabIdAndUrl(&start_params, left_tab);
-  start_params.AppendInteger(seconds);
-  scoped_refptr<WebrtcLoggingPrivateStartWebRtcEventLoggingFunction>
-      start_function(CreateExtensionFunction<
-                     WebrtcLoggingPrivateStartWebRtcEventLoggingFunction>());
-  std::unique_ptr<base::Value> start_result(
-      utils::RunFunctionAndReturnSingleResult(
-          start_function.get(), ParamsToString(start_params), browser()));
-  ASSERT_TRUE(start_result.get());
-
-  // Get the file name.
-  std::unique_ptr<extensions::api::webrtc_logging_private::RecordingInfo>
-      recordings_info_start(
-          extensions::api::webrtc_logging_private::RecordingInfo::FromValue(
-              *start_result));
-  ASSERT_TRUE(recordings_info_start.get());
-  base::FilePath file_name_start(
-      base::FilePath::FromUTF8Unsafe(recordings_info_start->prefix_path));
-
-#if !defined(OS_MACOSX)
-  // Video is choppy on Mac OS X. http://crbug.com/443542.
-  WaitForVideoToPlay(left_tab);
-  WaitForVideoToPlay(right_tab);
-#endif
-
-  HangUp(left_tab);
-  HangUp(right_tab);
-
-  // The log has stopped automatically. Check that the file exists and is
-  // non-empty.
-  content::RenderProcessHost* render_process_host =
-      left_tab->GetMainFrame()->GetProcess();
-  ASSERT_NE(render_process_host, nullptr);
-  int render_process_id = render_process_host->GetID();
-  base::FilePath full_file_name =
-      GetExpectedEventLogFileName(file_name_start, render_process_id);
-  int64_t file_size = 0;
-
-  scoped_refptr<FileWaiter> waiter = new FileWaiter(full_file_name);
-
-  ASSERT_TRUE(waiter->Start()) << "ERROR watching for "
-                               << full_file_name.value();
-  ASSERT_TRUE(waiter->WaitForFile());
-  ASSERT_TRUE(base::PathExists(full_file_name));
-  EXPECT_TRUE(base::GetFileSize(full_file_name, &file_size));
-  EXPECT_GT(file_size, 0);
-
-  // Clean up.
-  base::DeleteFile(full_file_name, false);
-}
diff --git a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc
index bc39d711427..233fb3e34d2 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.cc
@@ -69,10 +69,6 @@ namespace StartAudioDebugRecordings =
     api::webrtc_logging_private::StartAudioDebugRecordings;
 namespace StopAudioDebugRecordings =
     api::webrtc_logging_private::StopAudioDebugRecordings;
-namespace StartWebRtcEventLogging =
-    api::webrtc_logging_private::StartWebRtcEventLogging;
-namespace StopWebRtcEventLogging =
-    api::webrtc_logging_private::StopWebRtcEventLogging;
 namespace GetLogsDirectory = api::webrtc_logging_private::GetLogsDirectory;
 
 namespace {
@@ -528,63 +524,6 @@ bool WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::RunAsync() {
   return true;
 }
 
-bool WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::RunAsync() {
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableWebRtcEventLoggingFromExtension)) {
-    return false;
-  }
-
-  std::unique_ptr<StartWebRtcEventLogging::Params> params(
-      StartWebRtcEventLogging::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-  if (params->seconds < 0) {
-    FireErrorCallback("seconds must be greater than or equal to 0");
-    return true;
-  }
-
-  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
-      LoggingHandlerFromRequest(params->request, params->security_origin));
-  if (!webrtc_logging_handler_host.get())
-    return false;
-
-  webrtc_logging_handler_host->StartWebRtcEventLogging(
-      base::TimeDelta::FromSeconds(params->seconds),
-      base::Bind(
-          &WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::FireCallback,
-          this),
-      base::Bind(&WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::
-                     FireErrorCallback,
-                 this));
-
-  return true;
-}
-
-bool WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::RunAsync() {
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableWebRtcEventLoggingFromExtension)) {
-    return false;
-  }
-
-  std::unique_ptr<StopWebRtcEventLogging::Params> params(
-      StopWebRtcEventLogging::Params::Create(*args_));
-  EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  scoped_refptr<WebRtcLoggingHandlerHost> webrtc_logging_handler_host(
-      LoggingHandlerFromRequest(params->request, params->security_origin));
-  if (!webrtc_logging_handler_host.get())
-    return false;
-
-  webrtc_logging_handler_host->StopWebRtcEventLogging(
-      base::Bind(
-          &WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::FireCallback,
-          this),
-      base::Bind(&WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::
-                     FireErrorCallback,
-                 this));
-
-  return true;
-}
-
 bool WebrtcLoggingPrivateGetLogsDirectoryFunction::RunAsync() {
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
   // Unlike other WebrtcLoggingPrivate functions that take a RequestInfo object,
diff --git a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h
index 51fd692294d..1646e4893f4 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h
+++ b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h
@@ -12,8 +12,7 @@
 #include "media/media_features.h"
 
 #if BUILDFLAG(ENABLE_WEBRTC)
-#include "chrome/browser/media/audio_debug_recordings_handler.h"
-#include "chrome/browser/media/webrtc/webrtc_event_log_handler.h"
+#include "chrome/browser/media/webrtc/audio_debug_recordings_handler.h"
 #include "chrome/browser/media/webrtc/webrtc_logging_handler_host.h"
 #endif
 
@@ -257,34 +256,6 @@ class WebrtcLoggingPrivateStopAudioDebugRecordingsFunction
   bool RunAsync() override;
 };
 
-class WebrtcLoggingPrivateStartWebRtcEventLoggingFunction
-    : public WebrtcLoggingPrivateFunctionWithRecordingDoneCallback {
- public:
-  DECLARE_EXTENSION_FUNCTION("webrtcLoggingPrivate.startWebRtcEventLogging",
-                             WEBRTCLOGGINGPRIVATE_STARTRTCEVENTLOGGING)
-  WebrtcLoggingPrivateStartWebRtcEventLoggingFunction() {}
-
- private:
-  ~WebrtcLoggingPrivateStartWebRtcEventLoggingFunction() override {}
-
-  // ExtensionFunction overrides.
-  bool RunAsync() override;
-};
-
-class WebrtcLoggingPrivateStopWebRtcEventLoggingFunction
-    : public WebrtcLoggingPrivateFunctionWithRecordingDoneCallback {
- public:
-  DECLARE_EXTENSION_FUNCTION("webrtcLoggingPrivate.stopWebRtcEventLogging",
-                             WEBRTCLOGGINGPRIVATE_STOPRTCEVENTLOGGING)
-  WebrtcLoggingPrivateStopWebRtcEventLoggingFunction() {}
-
- private:
-  ~WebrtcLoggingPrivateStopWebRtcEventLoggingFunction() override {}
-
-  // ExtensionFunction overrides.
-  bool RunAsync() override;
-};
-
 class WebrtcLoggingPrivateGetLogsDirectoryFunction
     : public WebrtcLoggingPrivateFunction {
  public:
diff --git a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api_stub.cc b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api_stub.cc
index 0ec40efd20e..a47726a9a25 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api_stub.cc
+++ b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api_stub.cc
@@ -86,18 +86,6 @@ bool WebrtcLoggingPrivateStopAudioDebugRecordingsFunction::RunAsync() {
   return false;
 }
 
-bool WebrtcLoggingPrivateStartWebRtcEventLoggingFunction::RunAsync() {
-  SetError(kErrorNotSupported);
-  SendResponse(false);
-  return false;
-}
-
-bool WebrtcLoggingPrivateStopWebRtcEventLoggingFunction::RunAsync() {
-  SetError(kErrorNotSupported);
-  SendResponse(false);
-  return false;
-}
-
 bool WebrtcLoggingPrivateGetLogsDirectoryFunction::RunAsync() {
   SetError(kErrorNotSupported);
   SendResponse(false);
diff --git a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_browsertest.cc b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_browsertest.cc
index a0724f5fedb..c1a9c2fd7ae 100644
--- a/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_browsertest.cc
@@ -17,7 +17,8 @@ class WebrtcLoggingPrivateApiBrowserTest
   ~WebrtcLoggingPrivateApiBrowserTest() override = default;
 
   base::FilePath webrtc_logs_path() {
-    return WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile()->GetPath());
+    return WebRtcLogList::GetWebRtcLogDirectoryForBrowserContextPath(
+        profile()->GetPath());
   }
 
  private:
diff --git a/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_api.cc b/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_api.cc
index b6792c025b7..1b82d5446c9 100644
--- a/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_api.cc
@@ -10,7 +10,6 @@
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -218,18 +217,19 @@ WebstorePrivateBeginInstallWithManifest3Function::Run() {
   ActiveInstallData install_data(details().id);
   scoped_active_install_.reset(new ScopedActiveInstall(tracker, install_data));
 
-  net::URLRequestContextGetter* context_getter = nullptr;
+  network::mojom::URLLoaderFactory* loader_factory = nullptr;
   if (!icon_url.is_empty()) {
-    context_getter = content::BrowserContext::GetDefaultStoragePartition(
-        browser_context())->GetURLRequestContext();
+    loader_factory =
+        content::BrowserContext::GetDefaultStoragePartition(browser_context())
+            ->GetURLLoaderFactoryForBrowserProcess();
   }
 
   scoped_refptr<WebstoreInstallHelper> helper = new WebstoreInstallHelper(
-      this, details().id, details().manifest, icon_url, context_getter);
+      this, details().id, details().manifest, icon_url);
 
   // The helper will call us back via OnWebstoreParseSuccess or
   // OnWebstoreParseFailure.
-  helper->Start();
+  helper->Start(loader_factory);
 
   // Matched with a Release in OnWebstoreParseSuccess/OnWebstoreParseFailure.
   AddRef();
@@ -654,7 +654,7 @@ WebstorePrivateIsPendingCustodianApprovalFunction::Run() {
 
 ExtensionFunction::ResponseValue
 WebstorePrivateIsPendingCustodianApprovalFunction::BuildResponse(bool result) {
-  return OneArgument(base::MakeUnique<base::Value>(result));
+  return OneArgument(std::make_unique<base::Value>(result));
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc b/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc
index b845e30e9a6..85228f0e23a 100644
--- a/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc
@@ -427,8 +427,6 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebstoreGetWebGLStatusTest, Allowed) {
 // Tests getWebGLStatus function when WebGL is blacklisted.
 IN_PROC_BROWSER_TEST_F(ExtensionWebstoreGetWebGLStatusTest, Blocked) {
   content::GpuDataManager::GetInstance()->BlacklistWebGLForTesting();
-  EXPECT_TRUE(content::GpuDataManager::GetInstance()->IsFeatureBlacklisted(
-      gpu::GPU_FEATURE_TYPE_ACCELERATED_WEBGL));
 
   bool webgl_allowed = false;
   RunTest(webgl_allowed);
diff --git a/chromium/chrome/browser/extensions/api/webstore_widget_private/OWNERS b/chromium/chrome/browser/extensions/api/webstore_widget_private/OWNERS
index f8d2da3d782..655a9768915 100644
--- a/chromium/chrome/browser/extensions/api/webstore_widget_private/OWNERS
+++ b/chromium/chrome/browser/extensions/api/webstore_widget_private/OWNERS
@@ -3,5 +3,4 @@ tbarzic@chromium.org
 # chrome/browser/chromeos/file_manager/OWNERS
 hirono@chromium.org
 kinaba@chromium.org
-mtomasz@chromium.org
 yoshiki@chromium.org
author	Allan Sandfeld Jensen <allan.jensen@qt.io>	2018-01-31 16:33:43 +0100
committer	Allan Sandfeld Jensen <allan.jensen@qt.io>	2018-02-06 16:33:22 +0000
commit	da51f56cc21233c2d30f0fe0d171727c3102b2e0 (patch)
tree	4e579ab70ce4b19bee7984237f3ce05a96d59d83 /chromium/chrome/browser/extensions/api
parent	c8c2d1901aec01e934adf561a9fdf0cc776cdef8 (diff)