BASELINE: Update Chromium to 63.0.3239.58

Change-Id: Ia93b322a00ba4dd4004f3bcf1254063ba90e1605 Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
author: Allan Sandfeld Jensen <allan.jensen@qt.io> 2017-11-20 15:06:40 +0100
committer: Allan Sandfeld Jensen <allan.jensen@qt.io> 2017-11-22 11:48:58 +0000
commit: daa093eea7c773db06799a13bd7e4e2e2a9f8f14 (patch)
tree: 96cc5e7b9194c1b29eab927730bfa419e7111c25 /chromium/chrome/browser/extensions/api
parent: be59a35641616a4cf23c4a13fa0632624b021c1b (diff)
148 files changed, 2187 insertions, 1106 deletions
diff --git a/chromium/chrome/browser/extensions/api/DEPS b/chromium/chrome/browser/extensions/api/DEPS
index f33f52205a0..8b5b13f8183 100644
--- a/chromium/chrome/browser/extensions/api/DEPS
+++ b/chromium/chrome/browser/extensions/api/DEPS
@@ -3,6 +3,7 @@ include_rules = [
   "+chrome/browser/apps",
   "+components/about_handler",
   "+components/guest_view/common",
+  "+components/language/core/browser",
   "+device/hid",
    # Enable remote assistance on Chrome OS
   "+remoting/base",
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 6e28b1f58c2..cded076a9bb 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
@@ -33,14 +33,14 @@ using activity_log_private::ActivityResultSet;
 using activity_log_private::ExtensionActivity;
 using activity_log_private::Filter;
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<ActivityLogAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<ActivityLogAPI>>::
+    DestructorAtExit g_activity_log_private_api_factory =
+        LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<ActivityLogAPI>*
 ActivityLogAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_activity_log_private_api_factory.Pointer();
 }
 
 template <>
diff --git a/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc b/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc
index 5e299f0d067..68a3b47a7f5 100644
--- a/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/automation/automation_apitest.cc
@@ -286,6 +286,13 @@ IN_PROC_BROWSER_TEST_F(AutomationApiTest, TreeChange) {
       << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(AutomationApiTest, TreeChangeIndirect) {
+  StartEmbeddedTestServer();
+  ASSERT_TRUE(
+      RunExtensionSubtest("automation/tests/tabs", "tree_change_indirect.html"))
+      << message_;
+}
+
 IN_PROC_BROWSER_TEST_F(AutomationApiTest, DocumentSelection) {
   StartEmbeddedTestServer();
   ASSERT_TRUE(
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 1206ee39eff..b01bc990d6a 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
@@ -437,12 +437,12 @@ AutotestPrivateSetPlayStoreEnabledFunction::Run() {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<AutotestPrivateAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_autotest_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<AutotestPrivateAPI>*
 AutotestPrivateAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_autotest_private_api_factory.Pointer();
 }
 
 template <>
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 53abf8bcdc2..0d1ebac9e7d 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
@@ -270,12 +270,12 @@ void BookmarkManagerPrivateAPI::Shutdown() {
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_bookmark_manager_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BookmarkManagerPrivateAPI>*
 BookmarkManagerPrivateAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_bookmark_manager_private_api_factory.Pointer();
 }
 
 void BookmarkManagerPrivateAPI::OnListenerAdded(
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 1b74a4904d8..c4193769c2e 100644
--- a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
+++ b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
@@ -87,8 +87,7 @@ void PopulateBookmarkTreeNode(
         new double(floor(node->date_added().ToDoubleT() * 1000)));
   }
 
-  if (bookmarks::IsDescendantOf(node, managed->managed_node()) ||
-      bookmarks::IsDescendantOf(node, managed->supervised_node())) {
+  if (bookmarks::IsDescendantOf(node, managed->managed_node())) {
     out_bookmark_tree_node->unmodifiable =
         api::bookmarks::BOOKMARK_TREE_NODE_UNMODIFIABLE_MANAGED;
   }
@@ -135,8 +134,7 @@ bool RemoveNode(BookmarkModel* model,
     *error = keys::kModifySpecialError;
     return false;
   }
-  if (bookmarks::IsDescendantOf(node, managed->managed_node()) ||
-      bookmarks::IsDescendantOf(node, managed->supervised_node())) {
+  if (bookmarks::IsDescendantOf(node, managed->managed_node())) {
     *error = keys::kModifyManagedError;
     return false;
   }
diff --git a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
index b841d5f5f9d..46b1c776d0b 100644
--- a/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/bookmarks/bookmark_apitest.cc
@@ -29,41 +29,25 @@ using bookmarks::BookmarkModel;
 #define MAYBE_Bookmarks Bookmarks
 #endif
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MAYBE_Bookmarks) {
-  // Add test managed and supervised bookmarks to verify that the bookmarks API
-  // can read them and can't modify them.
+  // Add test managed bookmarks to verify that the bookmarks API can read them
+  // and can't modify them.
   Profile* profile = browser()->profile();
   BookmarkModel* model = BookmarkModelFactory::GetForBrowserContext(profile);
   bookmarks::ManagedBookmarkService* managed =
       ManagedBookmarkServiceFactory::GetForProfile(profile);
   bookmarks::test::WaitForBookmarkModelToLoad(model);
 
-  {
-    base::ListValue list;
-    std::unique_ptr<base::DictionaryValue> node(new base::DictionaryValue());
-    node->SetString("name", "Managed Bookmark");
-    node->SetString("url", "http://www.chromium.org");
-    list.Append(std::move(node));
-    node.reset(new base::DictionaryValue());
-    node->SetString("name", "Managed Folder");
-    node->Set("children", base::MakeUnique<base::ListValue>());
-    list.Append(std::move(node));
-    profile->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list);
-    ASSERT_EQ(2, managed->managed_node()->child_count());
-  }
-
-  {
-    base::ListValue list;
-    std::unique_ptr<base::DictionaryValue> node(new base::DictionaryValue());
-    node->SetString("name", "Supervised Bookmark");
-    node->SetString("url", "http://www.pbskids.org");
-    list.Append(std::move(node));
-    node.reset(new base::DictionaryValue());
-    node->SetString("name", "Supervised Folder");
-    node->Set("children", base::MakeUnique<base::ListValue>());
-    list.Append(std::move(node));
-    profile->GetPrefs()->Set(bookmarks::prefs::kSupervisedBookmarks, list);
-    ASSERT_EQ(2, managed->supervised_node()->child_count());
-  }
+  base::ListValue list;
+  std::unique_ptr<base::DictionaryValue> node(new base::DictionaryValue());
+  node->SetString("name", "Managed Bookmark");
+  node->SetString("url", "http://www.chromium.org");
+  list.Append(std::move(node));
+  node.reset(new base::DictionaryValue());
+  node->SetString("name", "Managed Folder");
+  node->Set("children", base::MakeUnique<base::ListValue>());
+  list.Append(std::move(node));
+  profile->GetPrefs()->Set(bookmarks::prefs::kManagedBookmarks, list);
+  ASSERT_EQ(2, managed->managed_node()->child_count());
 
   ASSERT_TRUE(RunExtensionTest("bookmarks")) << message_;
 }
diff --git a/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc b/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
index 6e5dc26dd00..7ba7a25d4f8 100644
--- a/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
+++ b/chromium/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
@@ -216,8 +216,7 @@ bool BookmarksFunction::CanBeModified(const BookmarkNode* node) {
     return false;
   }
   ManagedBookmarkService* managed = GetManagedBookmarkService();
-  if (::bookmarks::IsDescendantOf(node, managed->managed_node()) ||
-      ::bookmarks::IsDescendantOf(node, managed->supervised_node())) {
+  if (::bookmarks::IsDescendantOf(node, managed->managed_node())) {
     error_ = keys::kModifyManagedError;
     return false;
   }
@@ -404,14 +403,13 @@ void BookmarksAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<BookmarksAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<BookmarksAPI>>::
+    DestructorAtExit g_bookmarks_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BookmarksAPI>*
 BookmarksAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_bookmarks_api_factory.Pointer();
 }
 
 void BookmarksAPI::OnListenerAdded(const EventListenerInfo& details) {
diff --git a/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_api.cc b/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_api.cc
index 28e7612f554..99b7adffdb7 100644
--- a/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_api.cc
@@ -56,12 +56,12 @@ void BrailleDisplayPrivateAPI::Shutdown() {
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<BrailleDisplayPrivateAPI>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_braille_display_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BrailleDisplayPrivateAPI>*
 BrailleDisplayPrivateAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_braille_display_private_api_factory.Pointer();
 }
 
 void BrailleDisplayPrivateAPI::OnBrailleDisplayStateChanged(
diff --git a/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_apitest.cc b/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_apitest.cc
index fc092a6c9cb..3f507efa4d3 100644
--- a/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/braille_display_private/braille_display_private_apitest.cc
@@ -4,9 +4,8 @@
 
 #include <stddef.h>
 
-#include <deque>
-
 #include "base/bind.h"
+#include "base/containers/circular_deque.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
@@ -57,7 +56,7 @@ struct MockBrlapiConnectionData {
   std::vector<std::string> written_content;
   // List of brlapi key codes.  A negative number makes the connection mock
   // return an error from ReadKey.
-  std::deque<brlapi_keyCode_t> pending_keys;
+  base::circular_deque<brlapi_keyCode_t> pending_keys;
   // Causes a new display to appear to appear on disconnect, that is the
   // display size doubles and the controller gets notified of a brltty
   // restart.
diff --git a/chromium/chrome/browser/extensions/api/browsing_data/browsing_data_test.cc b/chromium/chrome/browser/extensions/api/browsing_data/browsing_data_test.cc
index a7359655aa4..d777b98d233 100644
--- a/chromium/chrome/browser/extensions/api/browsing_data/browsing_data_test.cc
+++ b/chromium/chrome/browser/extensions/api/browsing_data/browsing_data_test.cc
@@ -9,14 +9,15 @@
 #include "base/memory/ref_counted.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_util.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
-
 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 #include "chrome/browser/extensions/api/browsing_data/browsing_data_api.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "components/browsing_data/core/browsing_data_utils.h"
@@ -60,6 +61,11 @@ class ExtensionBrowsingDataTest : public InProcessBrowserTest {
   }
 
  protected:
+  void SetUp() override {
+    feature_list_.InitAndEnableFeature(features::kTabsInCbd);
+    InProcessBrowserTest::SetUp();
+  }
+
   void SetUpOnMainThread() override {
     remover_ =
         content::BrowserContext::GetBrowsingDataRemover(browser()->profile());
@@ -154,6 +160,9 @@ class ExtensionBrowsingDataTest : public InProcessBrowserTest {
                                  int expected_origin_type_mask,
                                  int expected_removal_mask) {
     PrefService* prefs = browser()->profile()->GetPrefs();
+    prefs->SetInteger(
+        browsing_data::prefs::kLastClearBrowsingDataTab,
+        static_cast<int>(browsing_data::ClearBrowsingDataTab::ADVANCED));
     prefs->SetBoolean(
         browsing_data::prefs::kDeleteCache,
         !!(data_type_flags & content::BrowsingDataRemover::DATA_TYPE_CACHE));
@@ -183,6 +192,35 @@ class ExtensionBrowsingDataTest : public InProcessBrowserTest {
         !!(data_type_flags &
            ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA));
 
+    VerifyRemovalMask(expected_origin_type_mask, expected_removal_mask);
+  }
+
+  void SetBasicPrefsAndVerifySettings(int data_type_flags,
+                                      int expected_origin_type_mask,
+                                      int expected_removal_mask) {
+    PrefService* prefs = browser()->profile()->GetPrefs();
+    prefs->SetInteger(
+        browsing_data::prefs::kLastClearBrowsingDataTab,
+        static_cast<int>(browsing_data::ClearBrowsingDataTab::BASIC));
+    prefs->SetBoolean(
+        browsing_data::prefs::kDeleteCacheBasic,
+        !!(data_type_flags & content::BrowsingDataRemover::DATA_TYPE_CACHE));
+    prefs->SetBoolean(
+        browsing_data::prefs::kDeleteCookiesBasic,
+        !!(data_type_flags & content::BrowsingDataRemover::DATA_TYPE_COOKIES));
+    prefs->SetBoolean(browsing_data::prefs::kDeleteBrowsingHistoryBasic,
+                      !!(data_type_flags &
+                         ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY));
+    prefs->SetBoolean(
+        prefs::kClearPluginLSODataEnabled,
+        !!(data_type_flags &
+           ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA));
+
+    VerifyRemovalMask(expected_origin_type_mask, expected_removal_mask);
+  }
+
+  void VerifyRemovalMask(int expected_origin_type_mask,
+                         int expected_removal_mask) {
     scoped_refptr<BrowsingDataSettingsFunction> function =
         new BrowsingDataSettingsFunction();
     SCOPED_TRACE("settings");
@@ -259,6 +297,7 @@ class ExtensionBrowsingDataTest : public InProcessBrowserTest {
   }
 
  private:
+  base::test::ScopedFeatureList feature_list_;
   // Cached pointer to BrowsingDataRemover for access to testing methods.
   content::BrowsingDataRemover* remover_;
 };
@@ -397,6 +436,9 @@ IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
 IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest,
                        BrowsingDataRemovalInputFromSettings) {
   PrefService* prefs = browser()->profile()->GetPrefs();
+  prefs->SetInteger(
+      browsing_data::prefs::kLastClearBrowsingDataTab,
+      static_cast<int>(browsing_data::ClearBrowsingDataTab::ADVANCED));
   prefs->SetBoolean(browsing_data::prefs::kDeleteCache, true);
   prefs->SetBoolean(browsing_data::prefs::kDeleteBrowsingHistory, true);
   prefs->SetBoolean(browsing_data::prefs::kDeleteDownloadHistory, true);
@@ -496,6 +538,12 @@ IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSimple) {
   SetPrefsAndVerifySettings(
       ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS, 0,
       ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS);
+  SetBasicPrefsAndVerifySettings(content::BrowsingDataRemover::DATA_TYPE_CACHE,
+                                 0,
+                                 content::BrowsingDataRemover::DATA_TYPE_CACHE);
+  SetBasicPrefsAndVerifySettings(
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, 0,
+      ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY);
 }
 
 // Test cookie and app data settings.
@@ -524,6 +572,9 @@ IN_PROC_BROWSER_TEST_F(ExtensionBrowsingDataTest, SettingsFunctionSiteData) {
       content::BrowsingDataRemover::DATA_TYPE_COOKIES |
           ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA,
       UNPROTECTED_WEB, supported_site_data);
+  SetBasicPrefsAndVerifySettings(
+      content::BrowsingDataRemover::DATA_TYPE_COOKIES, UNPROTECTED_WEB,
+      supported_site_data_except_plugins);
 }
 
 // Test an arbitrary assortment of settings.
diff --git a/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_apitest.cc b/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_apitest.cc
index ea3cebef72d..eef378df056 100644
--- a/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/certificate_provider/certificate_provider_apitest.cc
@@ -40,6 +40,7 @@
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/boringssl/src/include/openssl/evp.h"
+#include "third_party/boringssl/src/include/openssl/mem.h"
 #include "third_party/boringssl/src/include/openssl/rsa.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/textfield/textfield.h"
@@ -99,7 +100,7 @@ bool RsaSign(const std::vector<uint8_t>& digest,
       RSA_sign_raw(rsa_key, &len, signature->data(), signature->size(),
                    prefixed_digest, prefixed_digest_len, RSA_PKCS1_PADDING);
   if (is_alloced)
-    free(prefixed_digest);
+    OPENSSL_free(prefixed_digest);
 
   if (rv) {
     signature->resize(len);
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 58646f752a2..7354bf85df7 100644
--- a/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.cc
+++ b/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.cc
@@ -160,9 +160,10 @@ ChromeExtensionsAPIClient::CreateDevicePermissionsPrompt(
 }
 
 std::unique_ptr<VirtualKeyboardDelegate>
-ChromeExtensionsAPIClient::CreateVirtualKeyboardDelegate() const {
+ChromeExtensionsAPIClient::CreateVirtualKeyboardDelegate(
+    content::BrowserContext* browser_context) const {
 #if defined(OS_CHROMEOS)
-  return base::MakeUnique<ChromeVirtualKeyboardDelegate>();
+  return base::MakeUnique<ChromeVirtualKeyboardDelegate>(browser_context);
 #else
   return nullptr;
 #endif
diff --git a/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.h b/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.h
index eb300332f5b..7c5e18d6afa 100644
--- a/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.h
+++ b/chromium/chrome/browser/extensions/api/chrome_extensions_api_client.h
@@ -52,8 +52,8 @@ class ChromeExtensionsAPIClient : public ExtensionsAPIClient {
       RulesCacheDelegate* cache_delegate) const override;
   std::unique_ptr<DevicePermissionsPrompt> CreateDevicePermissionsPrompt(
       content::WebContents* web_contents) const override;
-  std::unique_ptr<VirtualKeyboardDelegate> CreateVirtualKeyboardDelegate()
-      const override;
+  std::unique_ptr<VirtualKeyboardDelegate> CreateVirtualKeyboardDelegate(
+      content::BrowserContext* browser_context) const override;
   ManagementAPIDelegate* CreateManagementAPIDelegate() const override;
   MetricsPrivateDelegate* GetMetricsPrivateDelegate() override;
   NetworkingCastPrivateDelegate* GetNetworkingCastPrivateDelegate() override;
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 71649982225..1c09509fdc4 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
@@ -8,13 +8,16 @@
 
 #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"
 #include "chrome/common/extensions/api/cloud_print_private.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/network_interfaces.h"
 #include "printing/features/features.h"
 
+#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
+#include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
+#include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
+#endif
+
 namespace extensions {
 
 namespace {
diff --git a/chromium/chrome/browser/extensions/api/commands/command_service.cc b/chromium/chrome/browser/extensions/api/commands/command_service.cc
index a5bc5e0b407..f59d3898b3e 100644
--- a/chromium/chrome/browser/extensions/api/commands/command_service.cc
+++ b/chromium/chrome/browser/extensions/api/commands/command_service.cc
@@ -142,14 +142,13 @@ CommandService::CommandService(content::BrowserContext* context)
 CommandService::~CommandService() {
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<CommandService>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<CommandService>>::
+    DestructorAtExit g_command_service_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CommandService>*
 CommandService::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_command_service_factory.Pointer();
 }
 
 // static
diff --git a/chromium/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc b/chromium/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc
index 7bb3c57a9ca..b08ffac01de 100644
--- a/chromium/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc
@@ -15,13 +15,13 @@
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_api.h"
 #include "chrome/browser/extensions/extension_apitest.h"
-#include "chrome/browser/lifetime/keep_alive_types.h"
-#include "chrome/browser/lifetime/scoped_keep_alive.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "components/keep_alive_registry/keep_alive_types.h"
+#include "components/keep_alive_registry/scoped_keep_alive.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_service.h"
diff --git a/chromium/chrome/browser/extensions/api/context_menus/context_menu_apitest.cc b/chromium/chrome/browser/extensions/api/context_menus/context_menu_apitest.cc
index 14294b8c46a..ebbabcf0c77 100644
--- a/chromium/chrome/browser/extensions/api/context_menus/context_menu_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/context_menus/context_menu_apitest.cc
@@ -74,8 +74,7 @@ class ExtensionContextMenuApiTest : public ExtensionApiTest {
     int num_found = 0;
     for (int i = 0; i < top_level_model_->GetItemCount(); i++) {
       int command_id = top_level_model_->GetCommandIdAt(i);
-      if (command_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST &&
-          command_id <= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST &&
+      if (ContextMenuMatcher::IsExtensionsCustomCommandId(command_id) &&
           top_level_model_->GetTypeAt(i) == type) {
         num_found++;
       }
diff --git a/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc b/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc
index ea47d9495f9..0f449f31348 100644
--- a/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc
+++ b/chromium/chrome/browser/extensions/api/cookies/cookies_api.cc
@@ -579,13 +579,12 @@ void CookiesAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<CookiesAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<CookiesAPI>>::
+    DestructorAtExit g_cookies_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<CookiesAPI>* CookiesAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_cookies_api_factory.Pointer();
 }
 
 void CookiesAPI::OnListenerAdded(const EventListenerInfo& details) {
diff --git a/chromium/chrome/browser/extensions/api/declarative/rules_registry_service_unittest.cc b/chromium/chrome/browser/extensions/api/declarative/rules_registry_service_unittest.cc
index be6f9671389..c9eaa346ce4 100644
--- a/chromium/chrome/browser/extensions/api/declarative/rules_registry_service_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/declarative/rules_registry_service_unittest.cc
@@ -69,8 +69,8 @@ TEST_F(RulesRegistryServiceTest, TestConstructionAndMultiThreading) {
 
   // Test registration.
 
-  registry_service.RegisterRulesRegistry(make_scoped_refptr(ui_registry));
-  registry_service.RegisterRulesRegistry(make_scoped_refptr(io_registry));
+  registry_service.RegisterRulesRegistry(base::WrapRefCounted(ui_registry));
+  registry_service.RegisterRulesRegistry(base::WrapRefCounted(io_registry));
 
   EXPECT_TRUE(registry_service.GetRulesRegistry(key, "ui").get());
   EXPECT_TRUE(registry_service.GetRulesRegistry(key, "io").get());
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 232b831a14c..8a24e609db7 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
@@ -255,7 +255,7 @@ TEST_F(RulesRegistryWithCacheTest, DeclarativeRulesStored) {
   value->AppendBoolean(true);
   cache_delegate->WriteToStorage(extension1_->id(), std::move(value));
   EXPECT_TRUE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   TestingValueStore* store = env_.GetExtensionSystem()->value_store();
   ASSERT_TRUE(store);
   EXPECT_EQ(1, store->write_count());
@@ -264,7 +264,7 @@ TEST_F(RulesRegistryWithCacheTest, DeclarativeRulesStored) {
   value.reset(new base::ListValue);
   cache_delegate->WriteToStorage(extension1_->id(), std::move(value));
   EXPECT_FALSE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   // No rules currently, but previously there were, so we expect a write.
   EXPECT_EQ(write_count + 1, store->write_count());
   write_count = store->write_count();
@@ -272,7 +272,7 @@ TEST_F(RulesRegistryWithCacheTest, DeclarativeRulesStored) {
   value.reset(new base::ListValue);
   cache_delegate->WriteToStorage(extension1_->id(), std::move(value));
   EXPECT_FALSE(cache_delegate->GetDeclarativeRulesStored(extension1_->id()));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   EXPECT_EQ(write_count, store->write_count());
 
   // 3. Test reading behavior.
@@ -280,13 +280,13 @@ TEST_F(RulesRegistryWithCacheTest, DeclarativeRulesStored) {
 
   cache_delegate->SetDeclarativeRulesStored(extension1_->id(), false);
   cache_delegate->ReadFromStorage(extension1_->id());
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   EXPECT_EQ(read_count, store->read_count());
   read_count = store->read_count();
 
   cache_delegate->SetDeclarativeRulesStored(extension1_->id(), true);
   cache_delegate->ReadFromStorage(extension1_->id());
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   EXPECT_EQ(read_count + 1, store->read_count());
 }
 
@@ -359,7 +359,7 @@ TEST_F(RulesRegistryWithCacheTest, RulesPreservedAcrossRestart) {
   AddRule(extension1_->id(), kRuleId, registry.get());
 
   // Posted tasks store the added rule.
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   EXPECT_EQ(1, GetNumberOfRules(extension1_->id(), registry.get()));
 
   // 3. Restart the TestRulesRegistry and see the rule still there.
@@ -369,7 +369,7 @@ TEST_F(RulesRegistryWithCacheTest, RulesPreservedAcrossRestart) {
                             cache_delegate.get(), kRulesRegistryID);
 
   // Posted tasks retrieve the stored rule.
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   EXPECT_EQ(1, GetNumberOfRules(extension1_->id(), registry.get()));
 }
 
@@ -385,7 +385,7 @@ TEST_F(RulesRegistryWithCacheTest, ConcurrentStoringOfRules) {
   EXPECT_EQ("", AddRule(extension1_->id(), kRuleId));
   EXPECT_EQ("", AddRule(extension2_->id(), kRule2Id));
   env_.GetExtensionSystem()->SetReady();
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   EXPECT_EQ(write_count + 2, system->value_store()->write_count());
 }
 
diff --git a/chromium/chrome/browser/extensions/api/declarative_net_request/DEPS b/chromium/chrome/browser/extensions/api/declarative_net_request/DEPS
new file mode 100644
index 00000000000..2a91b125ae3
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/declarative_net_request/DEPS
@@ -0,0 +1,3 @@
+include_rules = [
+  "+third_party/flatbuffers"
+]
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
new file mode 100644
index 00000000000..cea086bab19
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/declarative_net_request/declarative_net_request_browsertest.cc
@@ -0,0 +1,92 @@
+// 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 <vector>
+
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/test/histogram_tester.h"
+#include "base/threading/thread_restrictions.h"
+#include "chrome/browser/extensions/extension_browsertest.h"
+#include "extensions/browser/api/declarative_net_request/constants.h"
+#include "extensions/browser/api/declarative_net_request/test_utils.h"
+#include "extensions/common/api/declarative_net_request/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace extensions {
+namespace declarative_net_request {
+namespace {
+
+enum class ExtensionLoadType {
+  PACKED,
+  UNPACKED,
+};
+
+constexpr char kJSONRulesFilename[] = "rules_file.json";
+const base::FilePath::CharType kJSONRulesetFilepath[] =
+    FILE_PATH_LITERAL("rules_file.json");
+
+class DeclarativeNetRequestBrowserTest
+    : public ExtensionBrowserTest,
+      public ::testing::WithParamInterface<ExtensionLoadType> {
+ public:
+  DeclarativeNetRequestBrowserTest() {}
+
+  // Loads an extension with the given declarative |rules|. Should be called
+  // once per test.
+  void LoadExtensionWithRules(const std::vector<TestRule>& rules) {
+    base::ScopedAllowBlockingForTesting allow_blocking;
+    base::HistogramTester tester;
+
+    base::ScopedTempDir temp_dir;
+    EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
+
+    base::FilePath extension_dir =
+        temp_dir.GetPath().Append(FILE_PATH_LITERAL("test_extension"));
+    EXPECT_TRUE(base::CreateDirectory(extension_dir));
+
+    WriteManifestAndRuleset(extension_dir, kJSONRulesetFilepath,
+                            kJSONRulesFilename, rules);
+
+    const Extension* extension = nullptr;
+    switch (GetParam()) {
+      case ExtensionLoadType::PACKED:
+        extension = InstallExtension(extension_dir, 1 /* expected_change */);
+        break;
+      case ExtensionLoadType::UNPACKED:
+        extension = LoadExtension(extension_dir);
+        break;
+    }
+    ASSERT_TRUE(extension);
+
+    EXPECT_TRUE(HasValidIndexedRuleset(*extension, profile()));
+
+    int expected_histogram_count = 1;
+    tester.ExpectTotalCount(kIndexRulesTimeHistogram, expected_histogram_count);
+    tester.ExpectTotalCount(kIndexAndPersistRulesTimeHistogram,
+                            expected_histogram_count);
+    tester.ExpectBucketCount(kManifestRulesCountHistogram, rules.size(),
+                             expected_histogram_count);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DeclarativeNetRequestBrowserTest);
+};
+
+// Test that an extension with declarative rules loads successfully.
+IN_PROC_BROWSER_TEST_P(DeclarativeNetRequestBrowserTest, DNRExtension) {
+  LoadExtensionWithRules({CreateGenericRule()});
+}
+
+INSTANTIATE_TEST_CASE_P(,
+                        DeclarativeNetRequestBrowserTest,
+                        ::testing::Values(ExtensionLoadType::PACKED,
+                                          ExtensionLoadType::UNPACKED));
+
+}  // namespace
+}  // namespace declarative_net_request
+}  // namespace extensions
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
new file mode 100644
index 00000000000..860d213212b
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/declarative_net_request/rule_indexing_unittest.cc
@@ -0,0 +1,403 @@
+// 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 <stddef.h>
+#include <string>
+#include <vector>
+
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/histogram_tester.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/extension_service_test_base.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/version_info/version_info.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"
+#include "extensions/browser/test_extension_registry_observer.h"
+#include "extensions/common/api/declarative_net_request/test_utils.h"
+#include "extensions/common/features/feature_channel.h"
+#include "extensions/common/file_util.h"
+#include "extensions/common/install_warning.h"
+#include "extensions/common/manifest_constants.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace extensions {
+namespace declarative_net_request {
+namespace {
+
+enum class ExtensionLoadType {
+  PACKED,
+  UNPACKED,
+};
+
+constexpr char kJSONRulesFilename[] = "rules_file.json";
+const base::FilePath::CharType kJSONRulesetFilepath[] =
+    FILE_PATH_LITERAL("rules_file.json");
+
+// Fixure testing that declarative rules corresponding to the Declarative Net
+// Request API are correctly indexed, for both packed and unpacked
+// extensions.
+class RuleIndexingTest
+    : public ExtensionServiceTestBase,
+      public ::testing::WithParamInterface<ExtensionLoadType> {
+ public:
+  // Use channel UNKNOWN to ensure that the declarativeNetRequest API is
+  // available, irrespective of its actual availability.
+  RuleIndexingTest() : channel_(::version_info::Channel::UNKNOWN) {}
+
+  void SetUp() override {
+    ExtensionServiceTestBase::SetUp();
+    InitializeEmptyExtensionService();
+
+    loader_ = std::make_unique<ChromeTestExtensionLoader>(browser_context());
+    switch (GetParam()) {
+      case ExtensionLoadType::PACKED:
+        loader_->set_pack_extension(true);
+
+        // CrxInstaller reloads the extension after moving it, which causes an
+        // install warning for packed extensions due to the presence of
+        // kMetadata folder. However, this isn't actually surfaced to the user.
+        loader_->set_ignore_manifest_warnings(true);
+        break;
+      case ExtensionLoadType::UNPACKED:
+        loader_->set_pack_extension(false);
+        break;
+    }
+  }
+
+ protected:
+  void AddRule(const TestRule& rule) { rules_list_.push_back(rule); }
+
+  // This takes precedence over the AddRule method.
+  void SetRules(std::unique_ptr<base::Value> rules) {
+    rules_value_ = std::move(rules);
+  }
+
+  // Loads the extension and verifies the indexed ruleset location and histogram
+  // counts.
+  void LoadAndExpectSuccess(size_t expected_indexed_rules_count) {
+    base::HistogramTester tester;
+    WriteExtensionData();
+
+    loader_->set_should_fail(false);
+
+    // Clear all load errors before loading the extension.
+    error_reporter()->ClearErrors();
+
+    extension_ = loader_->LoadExtension(extension_dir_);
+    ASSERT_TRUE(extension_.get());
+
+    EXPECT_TRUE(HasValidIndexedRuleset(*extension_, profile()));
+
+    // Ensure no load errors were reported.
+    EXPECT_TRUE(error_reporter()->GetErrors()->empty());
+
+    tester.ExpectTotalCount(kIndexRulesTimeHistogram, 1);
+    tester.ExpectTotalCount(kIndexAndPersistRulesTimeHistogram, 1);
+    tester.ExpectBucketCount(kManifestRulesCountHistogram,
+                             expected_indexed_rules_count, 1);
+  }
+
+  void LoadAndExpectError(const std::string& expected_error) {
+    base::HistogramTester tester;
+    WriteExtensionData();
+
+    loader_->set_should_fail(true);
+
+    // Clear all load errors before loading the extension.
+    error_reporter()->ClearErrors();
+
+    extension_ = loader_->LoadExtension(extension_dir_);
+    EXPECT_FALSE(extension_.get());
+
+    // Verify the error. Only verify if the |expected_error| is a substring of
+    // the actual error, since some string may be prepended/appended while
+    // creating the actual error.
+    const std::vector<base::string16>* errors = error_reporter()->GetErrors();
+    ASSERT_EQ(1u, errors->size());
+    EXPECT_NE(base::string16::npos,
+              errors->at(0).find(base::UTF8ToUTF16(expected_error)))
+        << "expected: " << expected_error << " actual: " << errors->at(0);
+
+    tester.ExpectTotalCount(kIndexRulesTimeHistogram, 0u);
+    tester.ExpectTotalCount(kIndexAndPersistRulesTimeHistogram, 0u);
+    tester.ExpectTotalCount(kManifestRulesCountHistogram, 0u);
+  }
+
+  void set_persist_invalid_json_file() { persist_invalid_json_file_ = true; }
+
+  void set_persist_initial_indexed_ruleset() {
+    persist_initial_indexed_ruleset_ = true;
+  }
+
+  ChromeTestExtensionLoader* extension_loader() { return loader_.get(); }
+
+  const Extension* extension() const { return extension_.get(); }
+  void set_extension(scoped_refptr<const Extension> extension) {
+    extension_ = extension;
+  }
+
+ private:
+  void WriteExtensionData() {
+    extension_dir_ =
+        temp_dir().GetPath().Append(FILE_PATH_LITERAL("test_extension"));
+
+    // Create extension directory.
+    EXPECT_TRUE(base::CreateDirectory(extension_dir_));
+
+    if (rules_value_) {
+      WriteManifestAndRuleset(extension_dir_, kJSONRulesetFilepath,
+                              kJSONRulesFilename, *rules_value_);
+    } else {
+      WriteManifestAndRuleset(extension_dir_, kJSONRulesetFilepath,
+                              kJSONRulesFilename, rules_list_);
+    }
+
+    // Overwrite the JSON rules file with some invalid json.
+    if (persist_invalid_json_file_) {
+      std::string data = "invalid json";
+      base::WriteFile(extension_dir_.Append(kJSONRulesetFilepath), data.c_str(),
+                      data.size());
+    }
+
+    if (persist_initial_indexed_ruleset_) {
+      std::string data = "user ruleset";
+      base::WriteFile(file_util::GetIndexedRulesetPath(extension_dir_),
+                      data.c_str(), data.size());
+    }
+  }
+
+  ExtensionErrorReporter* error_reporter() {
+    return ExtensionErrorReporter::GetInstance();
+  }
+
+  ScopedCurrentChannel channel_;
+  std::vector<TestRule> rules_list_;
+  std::unique_ptr<base::Value> rules_value_;
+  base::FilePath extension_dir_;
+  std::unique_ptr<ChromeTestExtensionLoader> loader_;
+  scoped_refptr<const Extension> extension_;
+  bool persist_invalid_json_file_ = false;
+  bool persist_initial_indexed_ruleset_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(RuleIndexingTest);
+};
+
+TEST_P(RuleIndexingTest, DuplicateResourceTypes) {
+  TestRule rule = CreateGenericRule();
+  rule.condition->resource_types =
+      std::vector<std::string>({"image", "stylesheet"});
+  rule.condition->excluded_resource_types = std::vector<std::string>({"image"});
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_RESOURCE_TYPE_DUPLICATED, 0u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, EmptyRedirectRulePriority) {
+  TestRule rule = CreateGenericRule();
+  rule.action->type = std::string("redirect");
+  rule.action->redirect_url = std::string("https://google.com");
+  AddRule(rule);
+  LoadAndExpectError(
+      ParseInfo(ParseResult::ERROR_EMPTY_REDIRECT_RULE_PRIORITY, 0u)
+          .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, EmptyRedirectRuleUrl) {
+  TestRule rule = CreateGenericRule();
+  rule.id = kMinValidID;
+  AddRule(rule);
+
+  rule.id = kMinValidID + 1;
+  rule.action->type = std::string("redirect");
+  rule.priority = kMinValidPriority;
+  AddRule(rule);
+
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_EMPTY_REDIRECT_URL, 1u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, InvalidRuleID) {
+  TestRule rule = CreateGenericRule();
+  rule.id = kMinValidID - 1;
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_INVALID_RULE_ID, 0u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, InvalidRedirectRulePriority) {
+  TestRule rule = CreateGenericRule();
+  rule.action->type = std::string("redirect");
+  rule.action->redirect_url = std::string("https://google.com");
+  rule.priority = kMinValidPriority - 1;
+  AddRule(rule);
+  LoadAndExpectError(
+      ParseInfo(ParseResult::ERROR_INVALID_REDIRECT_RULE_PRIORITY, 0u)
+          .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, NoApplicableResourceTypes) {
+  TestRule rule = CreateGenericRule();
+  rule.condition->excluded_resource_types = std::vector<std::string>(
+      {"sub_frame", "stylesheet", "script", "image", "font", "object",
+       "xmlhttprequest", "ping", "media", "websocket", "other"});
+  AddRule(rule);
+  LoadAndExpectError(
+      ParseInfo(ParseResult::ERROR_NO_APPLICABLE_RESOURCE_TYPES, 0u)
+          .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, EmptyDomainsList) {
+  TestRule rule = CreateGenericRule();
+  rule.condition->domains = std::vector<std::string>();
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_EMPTY_DOMAINS_LIST, 0u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, EmptyResourceTypeList) {
+  TestRule rule = CreateGenericRule();
+  rule.condition->resource_types = std::vector<std::string>();
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_EMPTY_RESOURCE_TYPES_LIST, 0u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, EmptyURLFilter) {
+  TestRule rule = CreateGenericRule();
+  rule.condition->url_filter = std::string();
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_EMPTY_URL_FILTER, 0u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, InvalidRedirectURL) {
+  TestRule rule = CreateGenericRule();
+  rule.action->type = std::string("redirect");
+  rule.action->redirect_url = std::string("google");
+  rule.priority = kMinValidPriority;
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_INVALID_REDIRECT_URL, 0u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+TEST_P(RuleIndexingTest, ListNotPassed) {
+  SetRules(std::make_unique<base::DictionaryValue>());
+  LoadAndExpectError(manifest_errors::kDeclarativeNetRequestListNotPassed);
+}
+
+TEST_P(RuleIndexingTest, DuplicateIDS) {
+  TestRule rule = CreateGenericRule();
+  AddRule(rule);
+  AddRule(rule);
+  LoadAndExpectError(ParseInfo(ParseResult::ERROR_DUPLICATE_IDS, 1u)
+                         .GetErrorDescription(kJSONRulesFilename));
+}
+
+// Ensures that rules which can't be parsed are ignored and cause an install
+// warning.
+TEST_P(RuleIndexingTest, InvalidJSONRule) {
+  TestRule rule = CreateGenericRule();
+  AddRule(rule);
+
+  rule.id = kMinValidID + 1;
+  rule.action->type = std::string("invalid action");
+  AddRule(rule);
+
+  extension_loader()->set_ignore_manifest_warnings(true);
+  LoadAndExpectSuccess(1 /* rules count */);
+
+  // TODO(crbug.com/696822): CrxInstaller reloads the extension after moving it,
+  // which causes it to lose the install warning. This should be fixed.
+  if (GetParam() != ExtensionLoadType::PACKED) {
+    ASSERT_EQ(1u, extension()->install_warnings().size());
+    EXPECT_EQ(InstallWarning(kRulesNotParsedWarning,
+                             manifest_keys::kDeclarativeNetRequestKey,
+                             manifest_keys::kDeclarativeRuleResourcesKey),
+              extension()->install_warnings()[0]);
+  }
+}
+
+TEST_P(RuleIndexingTest, InvalidJSONFile) {
+  set_persist_invalid_json_file();
+  // The error is returned by the JSON parser we use. Hence just test that an
+  // error is thrown without verifying what it is.
+  LoadAndExpectError("");
+}
+
+TEST_P(RuleIndexingTest, EmptyRuleset) {
+  LoadAndExpectSuccess(0 /* rules count */);
+}
+
+TEST_P(RuleIndexingTest, AddSingleRule) {
+  AddRule(CreateGenericRule());
+  LoadAndExpectSuccess(1 /* rules count */);
+}
+
+TEST_P(RuleIndexingTest, AddTwoRules) {
+  TestRule rule = CreateGenericRule();
+  AddRule(rule);
+
+  rule.id = kMinValidID + 1;
+  AddRule(rule);
+  LoadAndExpectSuccess(2 /* rules count */);
+}
+
+TEST_P(RuleIndexingTest, ReloadExtension) {
+  AddRule(CreateGenericRule());
+  LoadAndExpectSuccess(1 /* rules count */);
+
+  base::HistogramTester tester;
+  TestExtensionRegistryObserver registry_observer(registry());
+
+  service()->ReloadExtension(extension()->id());
+  // Reloading should invalidate pointers to existing extension(). Hence reset
+  // it.
+  set_extension(
+      base::WrapRefCounted(registry_observer.WaitForExtensionLoaded()));
+
+  // Reloading the extension should cause the rules to be re-indexed in the
+  // case of unpacked extensions.
+  int expected_histogram_count = -1;
+  switch (GetParam()) {
+    case ExtensionLoadType::PACKED:
+      expected_histogram_count = 0;
+      break;
+    case ExtensionLoadType::UNPACKED:
+      expected_histogram_count = 1;
+      break;
+  }
+
+  tester.ExpectTotalCount(kIndexRulesTimeHistogram, expected_histogram_count);
+  tester.ExpectTotalCount(kIndexAndPersistRulesTimeHistogram,
+                          expected_histogram_count);
+  tester.ExpectBucketCount(kManifestRulesCountHistogram, 1 /* rules count */,
+                           expected_histogram_count);
+
+  // Ensure no install warnings were raised on reload.
+  EXPECT_TRUE(extension()->install_warnings().empty());
+}
+
+// Test that we do not use an extension provided indexed ruleset.
+TEST_P(RuleIndexingTest, ExtensionWithIndexedRuleset) {
+  set_persist_initial_indexed_ruleset();
+  AddRule(CreateGenericRule());
+  LoadAndExpectSuccess(1 /* rules count */);
+}
+
+INSTANTIATE_TEST_CASE_P(,
+                        RuleIndexingTest,
+                        ::testing::Values(ExtensionLoadType::PACKED,
+                                          ExtensionLoadType::UNPACKED));
+
+}  // namespace
+}  // namespace declarative_net_request
+}  // namespace extensions
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 93df4fd4de5..f3c85be5625 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
@@ -116,15 +116,15 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
           screen_list =
               g_picker_factory->CreateMediaList(DesktopMediaID::TYPE_SCREEN);
         } else {
-#if defined(USE_ASH)
+#if defined(OS_CHROMEOS)
           screen_list = base::MakeUnique<DesktopMediaListAsh>(
               DesktopMediaID::TYPE_SCREEN);
-#else   // !defined(USE_ASH)
+#else   // !defined(OS_CHROMEOS)
           screen_list = base::MakeUnique<NativeDesktopMediaList>(
               content::DesktopMediaID::TYPE_SCREEN,
               webrtc::DesktopCapturer::CreateScreenCapturer(
                   content::CreateDesktopCaptureOptions()));
-#endif  // !defined(USE_ASH)
+#endif  // !defined(OS_CHROMEOS)
         }
         have_screen_list = true;
         source_lists.push_back(std::move(screen_list));
@@ -139,10 +139,10 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
           window_list =
               g_picker_factory->CreateMediaList(DesktopMediaID::TYPE_WINDOW);
         } else {
-#if defined(USE_ASH)
+#if defined(OS_CHROMEOS)
           window_list = base::MakeUnique<DesktopMediaListAsh>(
               DesktopMediaID::TYPE_WINDOW);
-#else   // !defined(USE_ASH)
+#else   // !defined(OS_CHROMEOS)
           // NativeDesktopMediaList calls the capturers on a background thread.
           // This means that the two DesktopCapturer instances (for screens and
           // windows) created here cannot share the same DesktopCaptureOptions
@@ -152,7 +152,7 @@ bool DesktopCaptureChooseDesktopMediaFunctionBase::Execute(
               content::DesktopMediaID::TYPE_WINDOW,
               webrtc::DesktopCapturer::CreateWindowCapturer(
                   content::CreateDesktopCaptureOptions()));
-#endif  // !defined(USE_ASH)
+#endif  // !defined(OS_CHROMEOS)
         }
         have_window_list = true;
         source_lists.push_back(std::move(window_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 abcb32fa895..896842dd121 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
@@ -197,7 +197,8 @@ namespace PackDirectory = api::developer_private::PackDirectory;
 namespace Reload = api::developer_private::Reload;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<DeveloperPrivateAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_developer_private_api_factory =
+        LAZY_INSTANCE_INITIALIZER;
 
 class DeveloperPrivateAPI::WebContentsTracker
     : public content::WebContentsObserver {
@@ -223,7 +224,7 @@ class DeveloperPrivateAPI::WebContentsTracker
 // static
 BrowserContextKeyedAPIFactory<DeveloperPrivateAPI>*
 DeveloperPrivateAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_developer_private_api_factory.Pointer();
 }
 
 // static
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 c2907900851..05932026ddc 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
@@ -517,7 +517,7 @@ void ExtensionInfoGenerator::CreateExtensionInfoHelper(
 
   // Runs on all urls.
   ScriptingPermissionsModifier permissions_modifier(
-      browser_context_, make_scoped_refptr(&extension));
+      browser_context_, base::WrapRefCounted(&extension));
   info->run_on_all_urls.is_enabled =
       (FeatureSwitch::scripts_require_action()->IsEnabled() &&
        permissions_modifier.CanAffectExtension(
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 d0b197c6bcc..73578c61774 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
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/extensions/api/developer_private/inspectable_views_finder.h"
 
+#include <set>
+
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/developer_private.h"
 #include "content/public/browser/render_frame_host.h"
@@ -193,10 +195,10 @@ void InspectableViewsFinder::GetAppWindowViewsForExtension(
     if (url.is_empty())
       url = window->initial_url();
 
-    content::RenderProcessHost* process = web_contents->GetRenderProcessHost();
-    result->push_back(ConstructView(
-        url, process->GetID(), web_contents->GetMainFrame()->GetRoutingID(),
-        false, false, GetViewType(web_contents)));
+    content::RenderFrameHost* main_frame = web_contents->GetMainFrame();
+    result->push_back(ConstructView(url, main_frame->GetProcess()->GetID(),
+                                    main_frame->GetRoutingID(), false, false,
+                                    GetViewType(web_contents)));
   }
 }
 
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 c3345f1e297..ed86fa30914 100644
--- a/chromium/chrome/browser/extensions/api/device_permissions_manager_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/device_permissions_manager_unittest.cc
@@ -7,12 +7,9 @@
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
-#include "build/build_config.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/test/base/testing_profile.h"
 #include "device/base/mock_device_client.h"
-#include "device/hid/hid_device_info.h"
-#include "device/hid/mock_hid_service.h"
 #include "device/hid/public/interfaces/hid.mojom.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_service.h"
@@ -27,22 +24,25 @@ namespace extensions {
 
 namespace {
 
-using device::HidDeviceInfo;
 using device::MockUsbDevice;
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SetArgPointee;
 
-#if defined(OS_MACOSX)
-const uint64_t kTestDeviceIds[] = {1, 2, 3, 4};
-#else
-const char* kTestDeviceIds[] = {"A", "B", "C", "D"};
-#endif
+const char* kTestDeviceGuids[] = {"A", "B", "C", "D"};
+
+class FakeHidDeviceManager : public HidDeviceManager {
+ public:
+  explicit FakeHidDeviceManager(content::BrowserContext* context)
+      : HidDeviceManager(context) {}
+
+  void LazyInitialize() override {}
+};
 
 std::unique_ptr<KeyedService> CreateHidDeviceManager(
     content::BrowserContext* context) {
-  return base::MakeUnique<HidDeviceManager>(context);
+  return base::MakeUnique<FakeHidDeviceManager>(context);
 }
 
 }  // namespace
@@ -71,23 +71,30 @@ class DevicePermissionsManagerTest : public testing::Test {
     device2_ =
         new MockUsbDevice(0, 0, "Test Manufacturer", "Test Product", "12345");
     device3_ = new MockUsbDevice(0, 0, "Test Manufacturer", "Test Product", "");
-    device4_ = new HidDeviceInfo(
-        kTestDeviceIds[0], 0, 0, "Test HID Device", "abcde",
-        device::mojom::HidBusType::kHIDBusTypeUSB, std::vector<uint8_t>());
-    device_client_.hid_service()->AddDevice(device4_);
-    device5_ = new HidDeviceInfo(kTestDeviceIds[1], 0, 0, "Test HID Device", "",
-                                 device::mojom::HidBusType::kHIDBusTypeUSB,
-                                 std::vector<uint8_t>());
-    device_client_.hid_service()->AddDevice(device5_);
-    device6_ = new HidDeviceInfo(
-        kTestDeviceIds[2], 0, 0, "Test HID Device", "67890",
-        device::mojom::HidBusType::kHIDBusTypeUSB, std::vector<uint8_t>());
-    device_client_.hid_service()->AddDevice(device6_);
-    device7_ = new HidDeviceInfo(kTestDeviceIds[3], 0, 0, "Test HID Device", "",
-                                 device::mojom::HidBusType::kHIDBusTypeUSB,
-                                 std::vector<uint8_t>());
-    device_client_.hid_service()->AddDevice(device7_);
-    device_client_.hid_service()->FirstEnumerationComplete();
+
+    device4_ = device::mojom::HidDeviceInfo::New();
+    device4_->guid = kTestDeviceGuids[0];
+    device4_->product_name = "Test HID Device";
+    device4_->serial_number = "abcde";
+    device4_->bus_type = device::mojom::HidBusType::kHIDBusTypeUSB;
+
+    device5_ = device::mojom::HidDeviceInfo::New();
+    device5_->guid = kTestDeviceGuids[1];
+    device5_->product_name = "Test HID Device";
+    device5_->serial_number = "";
+    device5_->bus_type = device::mojom::HidBusType::kHIDBusTypeUSB;
+
+    device6_ = device::mojom::HidDeviceInfo::New();
+    device6_->guid = kTestDeviceGuids[2];
+    device6_->product_name = "Test HID Device";
+    device6_->serial_number = "67890";
+    device6_->bus_type = device::mojom::HidBusType::kHIDBusTypeUSB;
+
+    device7_ = device::mojom::HidDeviceInfo::New();
+    device7_->guid = kTestDeviceGuids[3];
+    device7_->product_name = "Test HID Device";
+    device7_->serial_number = "";
+    device7_->bus_type = device::mojom::HidBusType::kHIDBusTypeUSB;
   }
 
   void TearDown() override { env_.reset(nullptr); }
@@ -99,10 +106,10 @@ class DevicePermissionsManagerTest : public testing::Test {
   scoped_refptr<MockUsbDevice> device1_;
   scoped_refptr<MockUsbDevice> device2_;
   scoped_refptr<MockUsbDevice> device3_;
-  scoped_refptr<HidDeviceInfo> device4_;
-  scoped_refptr<HidDeviceInfo> device5_;
-  scoped_refptr<HidDeviceInfo> device6_;
-  scoped_refptr<HidDeviceInfo> device7_;
+  device::mojom::HidDeviceInfoPtr device4_;
+  device::mojom::HidDeviceInfoPtr device5_;
+  device::mojom::HidDeviceInfoPtr device6_;
+  device::mojom::HidDeviceInfoPtr device7_;
 };
 
 TEST_F(DevicePermissionsManagerTest, AllowAndClearDevices) {
@@ -110,8 +117,8 @@ TEST_F(DevicePermissionsManagerTest, AllowAndClearDevices) {
       DevicePermissionsManager::Get(env_->profile());
   manager->AllowUsbDevice(extension_->id(), device0_);
   manager->AllowUsbDevice(extension_->id(), device1_);
-  manager->AllowHidDevice(extension_->id(), *device4_->device());
-  manager->AllowHidDevice(extension_->id(), *device5_->device());
+  manager->AllowHidDevice(extension_->id(), *device4_);
+  manager->AllowHidDevice(extension_->id(), *device5_);
 
   DevicePermissions* device_permissions =
       manager->GetForExtension(extension_->id());
@@ -124,15 +131,13 @@ TEST_F(DevicePermissionsManagerTest, AllowAndClearDevices) {
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
   scoped_refptr<DevicePermissionEntry> device4_entry =
-      device_permissions->FindHidDeviceEntry(*device4_->device());
+      device_permissions->FindHidDeviceEntry(*device4_);
   ASSERT_TRUE(device4_entry.get());
   scoped_refptr<DevicePermissionEntry> device5_entry =
-      device_permissions->FindHidDeviceEntry(*device5_->device());
+      device_permissions->FindHidDeviceEntry(*device5_);
   ASSERT_TRUE(device5_entry.get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device6_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device7_->device()).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device6_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device7_).get());
   EXPECT_EQ(4U, device_permissions->entries().size());
 
   EXPECT_EQ(base::ASCIIToUTF16(
@@ -153,34 +158,26 @@ TEST_F(DevicePermissionsManagerTest, AllowAndClearDevices) {
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device1_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device6_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device7_->device()).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device5_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device6_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device7_).get());
   EXPECT_EQ(0U, device_permissions->entries().size());
 
   // After clearing device it should be possible to grant permission again.
   manager->AllowUsbDevice(extension_->id(), device0_);
   manager->AllowUsbDevice(extension_->id(), device1_);
-  manager->AllowHidDevice(extension_->id(), *device4_->device());
-  manager->AllowHidDevice(extension_->id(), *device5_->device());
+  manager->AllowHidDevice(extension_->id(), *device4_);
+  manager->AllowHidDevice(extension_->id(), *device5_);
 
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device0_).get());
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device1_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device6_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device7_->device()).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device5_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device6_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device7_).get());
 }
 
 TEST_F(DevicePermissionsManagerTest, DisconnectDevice) {
@@ -188,8 +185,8 @@ TEST_F(DevicePermissionsManagerTest, DisconnectDevice) {
       DevicePermissionsManager::Get(env_->profile());
   manager->AllowUsbDevice(extension_->id(), device0_);
   manager->AllowUsbDevice(extension_->id(), device1_);
-  manager->AllowHidDevice(extension_->id(), *device4_->device());
-  manager->AllowHidDevice(extension_->id(), *device5_->device());
+  manager->AllowHidDevice(extension_->id(), *device4_);
+  manager->AllowHidDevice(extension_->id(), *device5_);
 
   DevicePermissions* device_permissions =
       manager->GetForExtension(extension_->id());
@@ -197,23 +194,16 @@ TEST_F(DevicePermissionsManagerTest, DisconnectDevice) {
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device1_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device6_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device7_->device()).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device5_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device6_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device7_).get());
 
   device_client_.usb_service()->RemoveDevice(device0_);
   device_client_.usb_service()->RemoveDevice(device1_);
 
-  // Wait until HidDeviceManager::GetDevicesCallback is run. HidService
-  // won't send notifications to its observers before that.
-  base::RunLoop().RunUntilIdle();
-  device_client_.hid_service()->RemoveDevice(device4_->platform_device_id());
-  device_client_.hid_service()->RemoveDevice(device5_->platform_device_id());
+  manager->RemoveEntryByHidDeviceGUID(device4_->guid);
+  manager->RemoveEntryByHidDeviceGUID(device5_->guid);
 
   // Device 0 will be accessible when it is reconnected because it can be
   // recognized by its serial number.
@@ -225,15 +215,11 @@ TEST_F(DevicePermissionsManagerTest, DisconnectDevice) {
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
   // Device 4 is like device 0, but HID.
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device4_).get());
   // Device 5 is like device 1, but HID.
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device6_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device7_->device()).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device5_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device6_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device7_).get());
 }
 
 TEST_F(DevicePermissionsManagerTest, RevokeAndRegrantAccess) {
@@ -241,8 +227,8 @@ TEST_F(DevicePermissionsManagerTest, RevokeAndRegrantAccess) {
       DevicePermissionsManager::Get(env_->profile());
   manager->AllowUsbDevice(extension_->id(), device0_);
   manager->AllowUsbDevice(extension_->id(), device1_);
-  manager->AllowHidDevice(extension_->id(), *device4_->device());
-  manager->AllowHidDevice(extension_->id(), *device5_->device());
+  manager->AllowHidDevice(extension_->id(), *device4_);
+  manager->AllowHidDevice(extension_->id(), *device5_);
 
   DevicePermissions* device_permissions =
       manager->GetForExtension(extension_->id());
@@ -253,10 +239,10 @@ TEST_F(DevicePermissionsManagerTest, RevokeAndRegrantAccess) {
       device_permissions->FindUsbDeviceEntry(device1_);
   ASSERT_TRUE(device1_entry.get());
   scoped_refptr<DevicePermissionEntry> device4_entry =
-      device_permissions->FindHidDeviceEntry(*device4_->device());
+      device_permissions->FindHidDeviceEntry(*device4_);
   ASSERT_TRUE(device4_entry.get());
   scoped_refptr<DevicePermissionEntry> device5_entry =
-      device_permissions->FindHidDeviceEntry(*device5_->device());
+      device_permissions->FindHidDeviceEntry(*device5_);
   ASSERT_TRUE(device5_entry.get());
 
   manager->RemoveEntry(extension_->id(), device0_entry);
@@ -276,35 +262,27 @@ TEST_F(DevicePermissionsManagerTest, RevokeAndRegrantAccess) {
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device1_).get());
 
   manager->RemoveEntry(extension_->id(), device4_entry);
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device5_).get());
 
-  manager->AllowHidDevice(extension_->id(), *device4_->device());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
+  manager->AllowHidDevice(extension_->id(), *device4_);
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device5_).get());
 
   manager->RemoveEntry(extension_->id(), device5_entry);
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
-
-  manager->AllowHidDevice(extension_->id(), *device5_->device());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device4_->device()).get());
-  EXPECT_TRUE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device5_).get());
+
+  manager->AllowHidDevice(extension_->id(), *device5_);
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device4_).get());
+  EXPECT_TRUE(device_permissions->FindHidDeviceEntry(*device5_).get());
 }
 
 TEST_F(DevicePermissionsManagerTest, UpdateLastUsed) {
   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_->profile());
   manager->AllowUsbDevice(extension_->id(), device0_);
-  manager->AllowHidDevice(extension_->id(), *device4_->device());
+  manager->AllowHidDevice(extension_->id(), *device4_);
 
   DevicePermissions* device_permissions =
       manager->GetForExtension(extension_->id());
@@ -312,7 +290,7 @@ TEST_F(DevicePermissionsManagerTest, UpdateLastUsed) {
       device_permissions->FindUsbDeviceEntry(device0_);
   EXPECT_TRUE(device0_entry->last_used().is_null());
   scoped_refptr<DevicePermissionEntry> device4_entry =
-      device_permissions->FindHidDeviceEntry(*device4_->device());
+      device_permissions->FindHidDeviceEntry(*device4_);
   EXPECT_TRUE(device4_entry->last_used().is_null());
 
   manager->UpdateLastUsed(extension_->id(), device0_entry);
@@ -354,14 +332,11 @@ TEST_F(DevicePermissionsManagerTest, LoadPrefs) {
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
   scoped_refptr<DevicePermissionEntry> device4_entry =
-      device_permissions->FindHidDeviceEntry(*device4_->device());
+      device_permissions->FindHidDeviceEntry(*device4_);
   ASSERT_TRUE(device4_entry.get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device5_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device6_->device()).get());
-  EXPECT_FALSE(
-      device_permissions->FindHidDeviceEntry(*device7_->device()).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device5_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device6_).get());
+  EXPECT_FALSE(device_permissions->FindHidDeviceEntry(*device7_).get());
 
   EXPECT_EQ(base::ASCIIToUTF16(
                 "Test Product from Test Manufacturer (serial number ABCDE)"),
diff --git a/chromium/chrome/browser/extensions/api/dial/dial_api.cc b/chromium/chrome/browser/extensions/api/dial/dial_api.cc
index 8cb70bf0d54..1dd4d5883bd 100644
--- a/chromium/chrome/browser/extensions/api/dial/dial_api.cc
+++ b/chromium/chrome/browser/extensions/api/dial/dial_api.cc
@@ -11,6 +11,7 @@
 #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"
 #include "chrome/browser/media/router/discovery/dial/device_description_fetcher.h"
 #include "chrome/browser/media/router/discovery/dial/dial_registry.h"
@@ -19,6 +20,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_system.h"
+#include "net/url_request/url_request_context.h"
 #include "url/gurl.h"
 
 using base::TimeDelta;
@@ -34,6 +36,7 @@ DialAPI::DialAPI(Profile* profile)
     : RefcountedKeyedService(
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)),
       profile_(profile),
+      system_request_context_(g_browser_process->system_request_context()),
       dial_registry_(nullptr),
       num_on_device_list_listeners_(0) {
   EventRouter::Get(profile)->RegisterObserver(
@@ -53,6 +56,8 @@ DialRegistry* DialAPI::dial_registry() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!dial_registry_) {
     dial_registry_ = media_router::DialRegistry::GetInstance();
+    dial_registry_->SetNetLog(
+        system_request_context_->GetURLRequestContext()->net_log());
     dial_registry_->RegisterObserver(this);
     if (test_device_data_) {
       dial_registry_->AddDeviceForTest(*test_device_data_);
diff --git a/chromium/chrome/browser/extensions/api/dial/dial_api.h b/chromium/chrome/browser/extensions/api/dial/dial_api.h
index ee842663aba..e81ec17f9fb 100644
--- a/chromium/chrome/browser/extensions/api/dial/dial_api.h
+++ b/chromium/chrome/browser/extensions/api/dial/dial_api.h
@@ -8,12 +8,14 @@
 #include <memory>
 
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "chrome/browser/media/router/discovery/dial/dial_device_data.h"
 #include "chrome/browser/media/router/discovery/dial/dial_registry.h"
 #include "chrome/common/extensions/api/dial.h"
 #include "components/keyed_service/core/refcounted_keyed_service.h"
 #include "extensions/browser/api/async_api_function.h"
 #include "extensions/browser/event_router.h"
+#include "net/url_request/url_request_context_getter.h"
 
 namespace media_router {
 class DeviceDescriptionFetcher;
@@ -92,6 +94,11 @@ class DialAPI : public RefcountedKeyedService,
 
   Profile* profile_;
 
+  // Used to get its NetLog on the IOThread. It uses the same NetLog as the
+  // Profile, but the Profile's URLRequestContextGetter isn't ready when DialAPI
+  // is created.
+  scoped_refptr<net::URLRequestContextGetter> system_request_context_;
+
   // Created lazily on first access on the IO thread. Does not take ownership of
   // |dial_registry_|.
   media_router::DialRegistry* dial_registry_;
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 282febf7ac6..b4d3fb3b159 100644
--- a/chromium/chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/downloads/downloads_api_browsertest.cc
@@ -10,6 +10,7 @@
 
 #include <algorithm>
 
+#include "base/containers/circular_deque.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
@@ -43,6 +44,7 @@
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
@@ -237,7 +239,7 @@ class DownloadsEventsListener : public content::NotificationObserver {
   base::Time last_wait_;
   std::unique_ptr<Event> waiting_for_;
   content::NotificationRegistrar registrar_;
-  std::deque<std::unique_ptr<Event>> events_;
+  base::circular_deque<std::unique_ptr<Event>> events_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadsEventsListener);
 };
@@ -278,16 +280,13 @@ class DownloadExtensionTest : public ExtensionApiTest {
         ui::PAGE_TRANSITION_LINK);
     EventRouter::Get(current_browser()->profile())
         ->AddEventListener(downloads::OnCreated::kEventName,
-                           tab->GetRenderProcessHost(),
-                           GetExtensionId());
+                           tab->GetMainFrame()->GetProcess(), GetExtensionId());
     EventRouter::Get(current_browser()->profile())
         ->AddEventListener(downloads::OnChanged::kEventName,
-                           tab->GetRenderProcessHost(),
-                           GetExtensionId());
+                           tab->GetMainFrame()->GetProcess(), GetExtensionId());
     EventRouter::Get(current_browser()->profile())
         ->AddEventListener(downloads::OnErased::kEventName,
-                           tab->GetRenderProcessHost(),
-                           GetExtensionId());
+                           tab->GetMainFrame()->GetProcess(), GetExtensionId());
   }
 
   content::RenderProcessHost* AddFilenameDeterminer() {
@@ -299,9 +298,8 @@ class DownloadExtensionTest : public ExtensionApiTest {
         ui::PAGE_TRANSITION_LINK);
     EventRouter::Get(current_browser()->profile())
         ->AddEventListener(downloads::OnDeterminingFilename::kEventName,
-                           tab->GetRenderProcessHost(),
-                           GetExtensionId());
-    return tab->GetRenderProcessHost();
+                           tab->GetMainFrame()->GetProcess(), GetExtensionId());
+    return tab->GetMainFrame()->GetProcess();
   }
 
   void RemoveFilenameDeterminer(content::RenderProcessHost* host) {
@@ -1004,7 +1002,7 @@ IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
   download_item->Cancel(true);
   ASSERT_FALSE(download_item->GetTargetFilePath().empty());
   // Let cleanup complete on blocking threads.
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   // Check the path passed to the icon extractor post-cancellation.
   EXPECT_TRUE(RunFunctionAndReturnString(MockedGetFileIconFunction(
           download_item->GetTargetFilePath(), IconLoader::NORMAL, "foo"),
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 6da116e2e22..dd893701588 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
@@ -66,7 +66,8 @@ namespace easy_unlock_private = api::easy_unlock_private;
 namespace {
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_easy_unlock_private_api_factory =
+        LAZY_INSTANCE_INITIALIZER;
 
 // Utility method for getting the API's crypto delegate.
 EasyUnlockPrivateCryptoDelegate* GetCryptoDelegate(
@@ -115,7 +116,7 @@ ScreenlockState ToScreenlockState(easy_unlock_private::State state) {
 // static
 BrowserContextKeyedAPIFactory<EasyUnlockPrivateAPI>*
     EasyUnlockPrivateAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_easy_unlock_private_api_factory.Pointer();
 }
 
 EasyUnlockPrivateAPI::EasyUnlockPrivateAPI(content::BrowserContext* context)
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 7a1ad1de065..3985830467a 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
@@ -17,7 +17,6 @@
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
-#include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/easy_unlock_app_manager.h"
@@ -31,9 +30,7 @@
 #include "components/proximity_auth/switches.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "extensions/browser/api_test_utils.h"
-#include "extensions/browser/event_router.h"
-#include "extensions/browser/event_router_factory.h"
-#include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/test_event_router.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
@@ -482,48 +479,10 @@ std::unique_ptr<KeyedService> BuildTestEasyUnlockService(
   return std::move(service);
 }
 
-// A fake EventRouter that logs event it dispatches for testing.
-class FakeEventRouter : public extensions::EventRouter {
- public:
-  FakeEventRouter(
-      Profile* profile,
-      std::unique_ptr<extensions::TestExtensionPrefs> extension_prefs)
-      : EventRouter(profile, extension_prefs->prefs()),
-        extension_prefs_(std::move(extension_prefs)),
-        event_count_(0) {}
-
-  void DispatchEventToExtension(
-      const std::string& extension_id,
-      std::unique_ptr<extensions::Event> event) override {
-    ++event_count_;
-    last_extension_id_ = extension_id;
-    last_event_name_ = event ? event->event_name : std::string();
-  }
-
-  int event_count() const { return event_count_; }
-  const std::string& last_extension_id() const { return last_extension_id_; }
-  const std::string& last_event_name() const { return last_event_name_; }
-
- private:
-  std::unique_ptr<extensions::TestExtensionPrefs> extension_prefs_;
-  int event_count_;
-  std::string last_extension_id_;
-  std::string last_event_name_;
-};
-
-// FakeEventRouter factory function
-std::unique_ptr<KeyedService> FakeEventRouterFactoryFunction(
-    content::BrowserContext* profile) {
-  std::unique_ptr<extensions::TestExtensionPrefs> extension_prefs(
-      new extensions::TestExtensionPrefs(base::ThreadTaskRunnerHandle::Get()));
-  return base::MakeUnique<FakeEventRouter>(static_cast<Profile*>(profile),
-                                           std::move(extension_prefs));
-}
-
 TEST_F(EasyUnlockPrivateApiTest, AutoPairing) {
-  FakeEventRouter* event_router = static_cast<FakeEventRouter*>(
-      extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
-          profile(), &FakeEventRouterFactoryFunction));
+  extensions::TestEventRouter* event_router =
+      extensions::CreateAndUseTestEventRouter(profile());
+  event_router->set_expected_extension_id(extension_misc::kEasyUnlockAppId);
 
   EasyUnlockServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       profile(), &BuildTestEasyUnlockService);
@@ -534,12 +493,9 @@ TEST_F(EasyUnlockPrivateApiTest, AutoPairing) {
   EasyUnlockService* service = EasyUnlockService::Get(profile());
   service->StartAutoPairing(base::Bind(&AutoPairingResult::SetResult,
                                        base::Unretained(&result)));
-  EXPECT_EQ(1, event_router->event_count());
-  EXPECT_EQ(extension_misc::kEasyUnlockAppId,
-            event_router->last_extension_id());
-  EXPECT_EQ(
-      extensions::api::easy_unlock_private::OnStartAutoPairing::kEventName,
-      event_router->last_event_name());
+  EXPECT_EQ(1,
+            event_router->GetEventCount(extensions::api::easy_unlock_private::
+                                            OnStartAutoPairing::kEventName));
 
   // Test SetAutoPairingResult call with failure.
   scoped_refptr<EasyUnlockPrivateSetAutoPairingResultFunction> function(
diff --git a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection.cc b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection.cc
index f5cb2fdcf48..23d7ab5dc57 100644
--- a/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection.cc
+++ b/chromium/chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection.cc
@@ -11,12 +11,12 @@ namespace extensions {
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<
     ApiResourceManager<EasyUnlockPrivateConnection>>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_easy_unlock_private_connection_factory = LAZY_INSTANCE_INITIALIZER;
 
 template <>
 BrowserContextKeyedAPIFactory<ApiResourceManager<EasyUnlockPrivateConnection>>*
 ApiResourceManager<EasyUnlockPrivateConnection>::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_easy_unlock_private_connection_factory.Pointer();
 }
 
 EasyUnlockPrivateConnection::EasyUnlockPrivateConnection(
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 11e93b83263..6584caaf05a 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
@@ -202,19 +202,18 @@ void EPKPChallengeKeyBase::PrepareKey(
                                                       require_user_consent,
                                                       callback);
   cryptohome_client_->TpmAttestationIsPrepared(
-      base::Bind(&EPKPChallengeKeyBase::IsAttestationPreparedCallback,
-                 base::Unretained(this), context));
+      base::BindOnce(&EPKPChallengeKeyBase::IsAttestationPreparedCallback,
+                     base::Unretained(this), context));
 }
 
 void EPKPChallengeKeyBase::IsAttestationPreparedCallback(
     const PrepareKeyContext& context,
-    chromeos::DBusMethodCallStatus status,
-    bool result) {
-  if (status == chromeos::DBUS_METHOD_CALL_FAILURE) {
+    base::Optional<bool> result) {
+  if (!result.has_value()) {
     context.callback.Run(PREPARE_KEY_DBUS_ERROR);
     return;
   }
-  if (!result) {
+  if (!result.value()) {
     context.callback.Run(PREPARE_KEY_RESET_REQUIRED);
     return;
   }
@@ -222,20 +221,19 @@ void EPKPChallengeKeyBase::IsAttestationPreparedCallback(
   cryptohome_client_->TpmAttestationDoesKeyExist(
       context.key_type, cryptohome::Identification(context.account_id),
       context.key_name,
-      base::Bind(&EPKPChallengeKeyBase::DoesKeyExistCallback,
-                 base::Unretained(this), context));
+      base::BindOnce(&EPKPChallengeKeyBase::DoesKeyExistCallback,
+                     base::Unretained(this), context));
 }
 
 void EPKPChallengeKeyBase::DoesKeyExistCallback(
     const PrepareKeyContext& context,
-    chromeos::DBusMethodCallStatus status,
-    bool result) {
-  if (status == chromeos::DBUS_METHOD_CALL_FAILURE) {
+    base::Optional<bool> result) {
+  if (!result.has_value()) {
     context.callback.Run(PREPARE_KEY_DBUS_ERROR);
     return;
   }
 
-  if (result) {
+  if (result.value()) {
     // The key exists. Do nothing more.
     context.callback.Run(PREPARE_KEY_OK);
   } else {
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 7aae8291600..61ab6b36d32 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
@@ -13,11 +13,11 @@
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/optional.h"
 #include "chrome/common/extensions/api/enterprise_platform_keys_private.h"
 #include "chromeos/attestation/attestation_constants.h"
 #include "chromeos/attestation/attestation_flow.h"
 #include "chromeos/dbus/cryptohome_client.h"
-#include "chromeos/dbus/dbus_method_call_status.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/common/extension.h"
@@ -141,14 +141,10 @@ class EPKPChallengeKeyBase {
     const base::Callback<void(PrepareKeyResult)> callback;
   };
 
-  void IsAttestationPreparedCallback(
-      const PrepareKeyContext& context,
-      chromeos::DBusMethodCallStatus status,
-      bool result);
-  void DoesKeyExistCallback(
-      const PrepareKeyContext& context,
-      chromeos::DBusMethodCallStatus status,
-      bool result);
+  void IsAttestationPreparedCallback(const PrepareKeyContext& context,
+                                     base::Optional<bool> result);
+  void DoesKeyExistCallback(const PrepareKeyContext& context,
+                            base::Optional<bool> result);
   void AskForUserConsent(const base::Callback<void(bool)>& callback) const;
   void AskForUserConsentCallback(
       const PrepareKeyContext& context,
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 fb8b1b6bd60..ac88e53abad 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
@@ -29,7 +29,6 @@
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/cryptohome/mock_async_method_caller.h"
-#include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/prefs/pref_service.h"
@@ -59,23 +58,6 @@ const int kResetRequired = 4;
 
 const char kUserEmail[] = "test@google.com";
 
-// A simple functor to invoke a callback with predefined arguments.
-class FakeBoolDBusMethod {
- public:
-  FakeBoolDBusMethod(chromeos::DBusMethodCallStatus status, bool value)
-      : status_(status),
-        value_(value) {}
-
-  void operator() (const chromeos::BoolDBusMethodCallback& callback) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(callback, status_, value_));
-  }
-
- private:
-  chromeos::DBusMethodCallStatus status_;
-  bool value_;
-};
-
 void RegisterKeyCallbackTrue(
     chromeos::attestation::AttestationKeyType key_type,
     const cryptohome::Identification& user_id,
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 577edb34074..2709ca1089c 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
@@ -91,7 +91,7 @@ ExtensionActionAPI::Observer::~Observer() {
 //
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<ExtensionActionAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_extension_action_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 ExtensionActionAPI::ExtensionActionAPI(content::BrowserContext* context)
     : browser_context_(context),
@@ -129,7 +129,7 @@ ExtensionActionAPI::~ExtensionActionAPI() {
 // static
 BrowserContextKeyedAPIFactory<ExtensionActionAPI>*
 ExtensionActionAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_extension_action_api_factory.Pointer();
 }
 
 // static
@@ -358,7 +358,7 @@ bool ExtensionActionFunction::ExtractDataFromArguments() {
   if (!args_->Get(0, &first_arg))
     return true;
 
-  switch (first_arg->GetType()) {
+  switch (first_arg->type()) {
     case base::Value::Type::INTEGER:
       CHECK(first_arg->GetAsInteger(&tab_id_));
       break;
@@ -369,7 +369,7 @@ bool ExtensionActionFunction::ExtractDataFromArguments() {
       // Still need to check for the tabId within details.
       base::Value* tab_id_value = NULL;
       if (details_->Get("tabId", &tab_id_value)) {
-        switch (tab_id_value->GetType()) {
+        switch (tab_id_value->type()) {
           case base::Value::Type::NONE:
             // OK; tabId is optional, leave it default.
             return true;
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 b01ac06fa6e..2e5263cfbdb 100644
--- a/chromium/chrome/browser/extensions/api/feedback_private/feedback_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/feedback_private/feedback_browsertest.cc
@@ -85,7 +85,14 @@ class FeedbackTest : public ExtensionBrowserTest {
   }
 };
 
-IN_PROC_BROWSER_TEST_F(FeedbackTest, ShowFeedback) {
+// Disabled for ASan due to flakiness on Mac ASan 64 Tests (1).
+// See crbug.com/757243.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_ShowFeedback DISABLED_ShowFeedback
+#else
+#define MAYBE_ShowFeedback ShowFeedback
+#endif
+IN_PROC_BROWSER_TEST_F(FeedbackTest, MAYBE_ShowFeedback) {
   WaitForExtensionViewsToLoad();
 
   ASSERT_TRUE(IsFeedbackAppAvailable());
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 a9aac11aa72..a0bd54b184f 100644
--- a/chromium/chrome/browser/extensions/api/file_system/consent_provider.cc
+++ b/chromium/chrome/browser/extensions/api/file_system/consent_provider.cc
@@ -32,11 +32,9 @@ namespace {
 // List of whitelisted component apps and extensions by their ids for
 // chrome.fileSystem.requestFileSystem.
 const char* const kRequestFileSystemComponentWhitelist[] = {
-    file_manager::kFileManagerAppId,
-    file_manager::kVideoPlayerAppId,
-    file_manager::kGalleryAppId,
-    file_manager::kAudioPlayerAppId,
-    file_manager::kImageLoaderExtensionId,
+    file_manager::kFileManagerAppId, file_manager::kVideoPlayerAppId,
+    file_manager::kGalleryAppId, file_manager::kAudioPlayerAppId,
+    file_manager::kImageLoaderExtensionId, file_manager::kZipArchiverId,
     // TODO(mtomasz): Remove this extension id, and add it only for tests.
     "pkplfbidichfdicaijlchgnapepdginl"  // Testing extensions.
 };
diff --git a/chromium/chrome/browser/extensions/api/file_system/file_system_apitest_chromeos.cc b/chromium/chrome/browser/extensions/api/file_system/file_system_apitest_chromeos.cc
index cf7da48046e..f481fbb2637 100644
--- a/chromium/chrome/browser/extensions/api/file_system/file_system_apitest_chromeos.cc
+++ b/chromium/chrome/browser/extensions/api/file_system/file_system_apitest_chromeos.cc
@@ -139,7 +139,7 @@ class FileSystemApiTestForDrive : public PlatformAppBrowserTest {
     integration_service_->file_system()->GetResourceEntry(
         base::FilePath::FromUTF8Unsafe("drive/root"),  // whatever
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
-    content::RunAllBlockingPoolTasksUntilIdle();
+    content::RunAllTasksUntilIdle();
     ASSERT_EQ(drive::FILE_ERROR_OK, error);
   }
 
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 b2301aeba3e..dbb88d30ab0 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
@@ -43,7 +43,6 @@ std::unique_ptr<Notification> CreateAutoGrantedNotification(
   const std::string notification_id =
       extension.id() + "-" + volume->volume_id();
   message_center::RichNotificationData data;
-  data.clickable = false;
 
   // TODO(mtomasz): Share this code with RequestFileSystemDialogView.
   const base::string16 display_name =
@@ -78,7 +77,7 @@ void RequestFileSystemNotification::ShowAutoGrantedNotification(
     bool writable) {
   DCHECK(profile);
   scoped_refptr<RequestFileSystemNotification>
-      request_file_system_notification = make_scoped_refptr(
+      request_file_system_notification = base::WrapRefCounted(
           new RequestFileSystemNotification(profile, extension));
   std::unique_ptr<message_center::Notification> notification(
       CreateAutoGrantedNotification(
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 d5f5b63a025..eb57d222215 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
@@ -26,6 +26,7 @@
 #include "chrome/browser/extensions/api/preference/preference_api.h"
 #include "chrome/browser/extensions/api/preference/preference_helpers.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/font_pref_change_notifier_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/settings_utils.h"
 #include "chrome/common/extensions/api/font_settings.h"
@@ -54,42 +55,45 @@ const char kScriptKey[] = "script";
 const char kSetFromIncognitoError[] =
     "Can't modify regular settings from an incognito context.";
 
-// Format for font name preference paths.
-const char kWebKitFontPrefFormat[] = "webkit.webprefs.fonts.%s.%s";
-
 // Gets the font name preference path for |generic_family| and |script|. If
 // |script| is NULL, uses prefs::kWebKitCommonScript.
 std::string GetFontNamePrefPath(fonts::GenericFamily generic_family_enum,
                                 fonts::ScriptCode script_enum) {
-  std::string script = fonts::ToString(script_enum);
-  if (script.empty())
-    script = prefs::kWebKitCommonScript;
+  // Format is <prefix-(includes-dot)><family>.<script>
+  std::string result;
+  size_t prefix_len = strlen(pref_names_util::kWebKitFontPrefPrefix);
   std::string generic_family = fonts::ToString(generic_family_enum);
-  return base::StringPrintf(kWebKitFontPrefFormat,
-                            generic_family.c_str(),
-                            script.c_str());
-}
-
-// Registers |obs| to observe per-script font prefs under the path |map_name|.
-void RegisterFontFamilyMapObserver(
-    PrefChangeRegistrar* registrar,
-    const char* map_name,
-    const PrefChangeRegistrar::NamedChangeCallback& callback) {
-  for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
-    const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
-    registrar->Add(base::StringPrintf("%s.%s", map_name, script), callback);
-  }
+
+  // Script codes are 4, dot adds one more for 5.
+  result.reserve(prefix_len + generic_family.size() + 5);
+
+  result.append(pref_names_util::kWebKitFontPrefPrefix, prefix_len);
+  result.append(fonts::ToString(generic_family_enum));
+  result.push_back('.');
+
+  const char* script = fonts::ToString(script_enum);
+  if (script[0] == 0)  // Empty string.
+    result.append(prefs::kWebKitCommonScript);
+  else
+    result.append(script);
+  return result;
 }
 
 }  // namespace
 
-FontSettingsEventRouter::FontSettingsEventRouter(
-    Profile* profile) : profile_(profile) {
+FontSettingsEventRouter::FontSettingsEventRouter(Profile* profile)
+    : profile_(profile) {
   TRACE_EVENT0("browser,startup", "FontSettingsEventRouter::ctor")
   SCOPED_UMA_HISTOGRAM_TIMER("Extensions.FontSettingsEventRouterCtorTime");
 
   registrar_.Init(profile_->GetPrefs());
 
+  // Unretained is safe here because the registrar is owned by this class.
+  font_change_registrar_.Register(
+      FontPrefChangeNotifierFactory::GetForProfile(profile),
+      base::Bind(&FontSettingsEventRouter::OnFontFamilyMapPrefChanged,
+                 base::Unretained(this)));
+
   AddPrefToObserve(prefs::kWebKitDefaultFixedFontSize,
                    events::FONT_SETTINGS_ON_DEFAULT_FIXED_FONT_SIZE_CHANGED,
                    fonts::OnDefaultFixedFontSizeChanged::kEventName,
@@ -100,25 +104,6 @@ FontSettingsEventRouter::FontSettingsEventRouter(
   AddPrefToObserve(prefs::kWebKitMinimumFontSize,
                    events::FONT_SETTINGS_ON_MINIMUM_FONT_SIZE_CHANGED,
                    fonts::OnMinimumFontSizeChanged::kEventName, kPixelSizeKey);
-
-  PrefChangeRegistrar::NamedChangeCallback callback =
-      base::Bind(&FontSettingsEventRouter::OnFontFamilyMapPrefChanged,
-                 base::Unretained(this));
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitStandardFontFamilyMap, callback);
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitSerifFontFamilyMap, callback);
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitSansSerifFontFamilyMap, callback);
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitFixedFontFamilyMap, callback);
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitCursiveFontFamilyMap, callback);
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitFantasyFontFamilyMap, callback);
-  RegisterFontFamilyMapObserver(&registrar_,
-                                prefs::kWebKitPictographFontFamilyMap,
-                                callback);
 }
 
 FontSettingsEventRouter::~FontSettingsEventRouter() {}
@@ -202,12 +187,12 @@ FontSettingsAPI::~FontSettingsAPI() {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<FontSettingsAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_font_settings_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<FontSettingsAPI>*
 FontSettingsAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_font_settings_api_factory.Pointer();
 }
 
 ExtensionFunction::ResponseAction FontSettingsClearFontFunction::Run() {
diff --git a/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.h b/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.h
index 964535c887f..880218aba60 100644
--- a/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.h
+++ b/chromium/chrome/browser/extensions/api/font_settings/font_settings_api.h
@@ -13,6 +13,7 @@
 
 #include "base/macros.h"
 #include "chrome/browser/extensions/chrome_extension_function.h"
+#include "chrome/browser/font_pref_change_notifier.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/prefs/pref_service.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
@@ -68,6 +69,7 @@ class FontSettingsEventRouter {
 
   // Manages pref observation registration.
   PrefChangeRegistrar registrar_;
+  FontPrefChangeNotifier::Registrar font_change_registrar_;
 
   // Weak, owns us (transitively via ExtensionService).
   Profile* profile_;
diff --git a/chromium/chrome/browser/extensions/api/history/history_api.cc b/chromium/chrome/browser/extensions/api/history/history_api.cc
index c80346ed4d8..fe4f312e062 100644
--- a/chromium/chrome/browser/extensions/api/history/history_api.cc
+++ b/chromium/chrome/browser/extensions/api/history/history_api.cc
@@ -195,13 +195,12 @@ void HistoryAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<HistoryAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<HistoryAPI>>::
+    DestructorAtExit g_history_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<HistoryAPI>* HistoryAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_history_api_factory.Pointer();
 }
 
 template <>
diff --git a/chromium/chrome/browser/extensions/api/hotword_private/hotword_private_api.cc b/chromium/chrome/browser/extensions/api/hotword_private/hotword_private_api.cc
index 05389bdd8bd..6976c1b83bf 100644
--- a/chromium/chrome/browser/extensions/api/hotword_private/hotword_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/hotword_private/hotword_private_api.cc
@@ -46,7 +46,7 @@ namespace OnEnabledChanged =
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<HotwordPrivateEventService>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_hotword_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 HotwordPrivateEventService::HotwordPrivateEventService(
     content::BrowserContext* context)
@@ -71,7 +71,7 @@ void HotwordPrivateEventService::Shutdown() {
 // static
 BrowserContextKeyedAPIFactory<HotwordPrivateEventService>*
 HotwordPrivateEventService::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_hotword_private_api_factory.Pointer();
 }
 
 // static
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_api.cc b/chromium/chrome/browser/extensions/api/identity/identity_api.cc
index 48193405b88..1838933cb86 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_api.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_api.cc
@@ -112,8 +112,7 @@ IdentityAPI::IdentityAPI(content::BrowserContext* context)
           LoginUIServiceFactory::GetShowLoginPopupCallbackForProfile(
               Profile::FromBrowserContext(context))),
       account_tracker_(&profile_identity_provider_,
-                       g_browser_process->system_request_context()),
-      get_auth_token_function_(nullptr) {
+                       g_browser_process->system_request_context()) {
   account_tracker_.AddObserver(this);
 }
 
@@ -155,19 +154,17 @@ const IdentityAPI::CachedTokens& IdentityAPI::GetAllCachedTokens() {
 }
 
 void IdentityAPI::Shutdown() {
-  if (get_auth_token_function_)
-    get_auth_token_function_->Shutdown();
+  on_shutdown_callback_list_.Notify();
   account_tracker_.RemoveObserver(this);
   account_tracker_.Shutdown();
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<IdentityAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<IdentityAPI>>::
+    DestructorAtExit g_identity_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<IdentityAPI>* IdentityAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_identity_api_factory.Pointer();
 }
 
 void IdentityAPI::OnAccountSignInChanged(const gaia::AccountIds& ids,
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_api.h b/chromium/chrome/browser/extensions/api/identity/identity_api.h
index 544ff271aaa..8f86f57469e 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_api.h
+++ b/chromium/chrome/browser/extensions/api/identity/identity_api.h
@@ -11,6 +11,7 @@
 #include <utility>
 #include <vector>
 
+#include "base/callback_list.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ -39,8 +40,6 @@ class BrowserContext;
 
 namespace extensions {
 
-class IdentityGetAuthTokenFunction;
-
 class IdentityTokenCacheValue {
  public:
   IdentityTokenCacheValue();
@@ -101,9 +100,9 @@ class IdentityAPI : public BrowserContextKeyedAPI,
   void OnAccountSignInChanged(const gaia::AccountIds& ids,
                               bool is_signed_in) override;
 
-  void set_get_auth_token_function(
-      IdentityGetAuthTokenFunction* get_auth_token_function) {
-    get_auth_token_function_ = get_auth_token_function;
+  std::unique_ptr<base::CallbackList<void()>::Subscription>
+  RegisterOnShutdownCallback(const base::Closure& cb) {
+    return on_shutdown_callback_list_.Add(cb);
   }
 
   // TODO(blundell): Eliminate this method once this class is no longer using
@@ -135,8 +134,7 @@ class IdentityAPI : public BrowserContextKeyedAPI,
 
   OnSignInChangedCallback on_signin_changed_callback_for_testing_;
 
-  // May be null.
-  IdentityGetAuthTokenFunction* get_auth_token_function_;
+  base::CallbackList<void()> on_shutdown_callback_list_;
 };
 
 template <>
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc b/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc
index 07d9e82c4ab..c9a3996654e 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/identity/identity_apitest.cc
@@ -86,13 +86,13 @@ namespace utils = extension_function_test_utils;
 static const char kAccessToken[] = "auth_token";
 static const char kExtensionId[] = "ext_id";
 
-class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
- protected:
-  // Asynchronous function runner allows tests to manipulate the browser window
-  // after the call happens.
-  void RunFunctionAsync(
-      UIThreadExtensionFunction* function,
-      const std::string& args) {
+// Asynchronous function runner allows tests to manipulate the browser window
+// after the call happens.
+class AsyncFunctionRunner {
+ public:
+  void RunFunctionAsync(UIThreadExtensionFunction* function,
+                        const std::string& args,
+                        content::BrowserContext* browser_context) {
     response_delegate_.reset(new api_test_utils::SendResponseHelper(function));
     std::unique_ptr<base::ListValue> parsed_args(utils::ParseList(args));
     EXPECT_TRUE(parsed_args.get()) <<
@@ -105,7 +105,7 @@ class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
       function->set_extension(empty_extension.get());
     }
 
-    function->set_browser_context(browser()->profile());
+    function->set_browser_context(browser_context);
     function->set_has_callback(true);
     function->RunWithValidation()->Execute();
   }
@@ -138,6 +138,28 @@ class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
   std::unique_ptr<api_test_utils::SendResponseHelper> response_delegate_;
 };
 
+class AsyncExtensionBrowserTest : public ExtensionBrowserTest {
+ protected:
+  // Provide wrappers of AsynchronousFunctionRunner for convenience.
+  void RunFunctionAsync(UIThreadExtensionFunction* function,
+                        const std::string& args) {
+    async_function_runner_ = base::MakeUnique<AsyncFunctionRunner>();
+    async_function_runner_->RunFunctionAsync(function, args,
+                                             browser()->profile());
+  }
+
+  std::string WaitForError(UIThreadExtensionFunction* function) {
+    return async_function_runner_->WaitForError(function);
+  }
+
+  base::Value* WaitForSingleResult(UIThreadExtensionFunction* function) {
+    return async_function_runner_->WaitForSingleResult(function);
+  }
+
+ private:
+  std::unique_ptr<AsyncFunctionRunner> async_function_runner_;
+};
+
 class TestHangOAuth2MintTokenFlow : public OAuth2MintTokenFlow {
  public:
   TestHangOAuth2MintTokenFlow()
@@ -554,7 +576,7 @@ class IdentityGetAccountsFunctionTest : public IdentityTestWithSignin {
         if (info.get())
           msg << info->id << " ";
         else
-          msg << result << "<-" << result.GetType() << " ";
+          msg << result << "<-" << result.type() << " ";
       }
     }
 
@@ -1300,7 +1322,7 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, InteractiveQueueShutdown) {
   EXPECT_FALSE(func->scope_ui_shown());
 
   // After the request is canceled, the function will complete.
-  func->Shutdown();
+  func->OnIdentityAPIShutdown();
   EXPECT_EQ(std::string(errors::kCanceled), WaitForError(func.get()));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->scope_ui_shown());
@@ -1318,7 +1340,7 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, NoninteractiveShutdown) {
   RunFunctionAsync(func.get(), "[{\"interactive\": false}]");
 
   // After the request is canceled, the function will complete.
-  func->Shutdown();
+  func->OnIdentityAPIShutdown();
   EXPECT_EQ(std::string(errors::kCanceled), WaitForError(func.get()));
 }
 
@@ -1480,6 +1502,62 @@ IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, ComponentWithNormalClientId) {
   EXPECT_EQ("client1", func->GetOAuth2ClientId());
 }
 
+// Ensure that IdentityAPI shutdown triggers an active function call to return
+// with an error.
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, IdentityAPIShutdown) {
+  scoped_refptr<FakeGetAuthTokenFunction> func(new FakeGetAuthTokenFunction());
+  scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
+  func->set_extension(extension.get());
+  func->set_mint_token_result(TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS);
+
+  // Have GetAuthTokenFunction actually make the request for the access token to
+  // ensure that the function doesn't immediately succeed.
+  func->set_auto_login_access_token(false);
+  RunFunctionAsync(func.get(), "[{}]");
+
+  id_api()->Shutdown();
+  EXPECT_EQ(std::string(errors::kCanceled), WaitForError(func.get()));
+}
+
+// Ensure that when there are multiple active function calls, IdentityAPI
+// shutdown triggers them all to return with errors.
+IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest,
+                       IdentityAPIShutdownWithMultipleActiveTokenRequests) {
+  // Set up two extension functions, having them actually make the request for
+  // the access token to ensure that they don't immediately succeed.
+  scoped_refptr<FakeGetAuthTokenFunction> func1(new FakeGetAuthTokenFunction());
+  scoped_refptr<const Extension> extension1(
+      CreateExtension(CLIENT_ID | SCOPES));
+  func1->set_extension(extension1.get());
+  func1->set_mint_token_result(TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS);
+  func1->set_auto_login_access_token(false);
+
+  scoped_refptr<FakeGetAuthTokenFunction> func2(new FakeGetAuthTokenFunction());
+  scoped_refptr<const Extension> extension2(
+      CreateExtension(CLIENT_ID | SCOPES));
+  func2->set_extension(extension2.get());
+  func2->set_mint_token_result(TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS);
+  func2->set_auto_login_access_token(false);
+
+  // Run both functions. Note that it's necessary to use AsyncFunctionRunner
+  // directly here rather than the AsyncExtensionBrowserTest instance methods
+  // that wrap it, as each AsyncFunctionRunner instance sets itself as the
+  // delegate of exactly one function.
+  AsyncFunctionRunner func1_runner;
+  func1_runner.RunFunctionAsync(func1.get(), "[{}]", browser()->profile());
+
+  AsyncFunctionRunner func2_runner;
+  func2_runner.RunFunctionAsync(func2.get(), "[{}]", browser()->profile());
+
+  // Shut down IdentityAPI and ensure that both functions complete with an
+  // error.
+  id_api()->Shutdown();
+  EXPECT_EQ(std::string(errors::kCanceled),
+            func1_runner.WaitForError(func1.get()));
+  EXPECT_EQ(std::string(errors::kCanceled),
+            func2_runner.WaitForError(func2.get()));
+}
+
 IN_PROC_BROWSER_TEST_F(GetAuthTokenFunctionTest, ManuallyIssueToken) {
   SignIn("primary@example.com");
 
@@ -2050,11 +2128,13 @@ class OnSignInChangedEventTest : public IdentityTestWithSignin {
     return IdentityAPI::GetFactoryInstance()->Get(browser()->profile());
   }
 
-  // Adds an event that is expected to fire. Events are checked in the order of
-  // addition, i.e., the first event added is expected to be the first event to
-  // fire.
+  // Adds an event that is expected to fire. Events are unordered, i.e., when an
+  // event fires it will be checked against all of the expected events that have
+  // been added. This is because the order of multiple events firing due to the
+  // same underlying state change is undefined in the
+  // chrome.identity.onSignInEventChanged() API.
   void AddExpectedEvent(std::unique_ptr<base::ListValue> args) {
-    expected_events_.push_back(
+    expected_events_.insert(
         base::MakeUnique<Event>(events::IDENTITY_ON_SIGN_IN_CHANGED,
                                 api::identity::OnSignInChanged::kEventName,
                                 std::move(args), browser()->profile()));
@@ -2067,18 +2147,37 @@ class OnSignInChangedEventTest : public IdentityTestWithSignin {
     if (!HasExpectedEvent())
       return;
 
-    // Check that |event| matches the first event expected to fire.
-    const auto& expected_event = expected_events_[0];
-    EXPECT_EQ(expected_event->histogram_value, event->histogram_value);
-    EXPECT_EQ(expected_event->event_name, event->event_name);
-    EXPECT_EQ(*(expected_event->event_args.get()), *(event->event_args.get()));
+    // Search for |event| in the set of expected events.
+    bool found_event = false;
+    const auto* event_args = event->event_args.get();
+    for (const auto& expected_event : expected_events_) {
+      EXPECT_EQ(expected_event->histogram_value, event->histogram_value);
+      EXPECT_EQ(expected_event->event_name, event->event_name);
+
+      const auto* expected_event_args = expected_event->event_args.get();
+      if (*event_args != *expected_event_args)
+        continue;
+
+      expected_events_.erase(expected_event);
+      found_event = true;
+      break;
+    }
+
+    if (!found_event) {
+      EXPECT_TRUE(false) << "Received bad event:";
+
+      LOG(INFO) << "Was expecting events with these args:";
 
-    // Erase that first element whether it matched or not, since it's no longer
-    // expected.
-    expected_events_.erase(expected_events_.begin());
+      for (const auto& expected_event : expected_events_) {
+        LOG(INFO) << *(expected_event->event_args.get());
+      }
+
+      LOG(INFO) << "But received event with different args:";
+      LOG(INFO) << *event_args;
+    }
   }
 
-  std::vector<std::unique_ptr<Event>> expected_events_;
+  std::set<std::unique_ptr<Event>> expected_events_;
 };
 
 // Test that an event is fired when the primary account signs in.
@@ -2190,10 +2289,38 @@ IN_PROC_BROWSER_TEST_F(OnSignInChangedEventTest,
   EXPECT_TRUE(HasExpectedEvent());
 }
 
+// The below tests involve elements that aren't relevant on ChromeOS:
+// - Signin of secondary accounts before the primary account signs in. On
+//   ChromeOS, this isn't possible.
+// - Signout of the primary account. On ChromeOS, this isn't possible.
 #if !defined(OS_CHROMEOS)
+// Test that signin events are fired for all known accounts when the primary
+// account signs in and there is a secondary account already present. Note that
+// the order in which the events fire is undefined.
+IN_PROC_BROWSER_TEST_F(OnSignInChangedEventTest,
+                       FireForAllAccountsOnPrimaryAccountSignIn) {
+  id_api()->SetAccountStateForTesting("primary", false);
+  id_api()->SetAccountStateForTesting("secondary", false);
+
+  api::identity::AccountInfo account_info;
+  account_info.id = "secondary";
+  AddExpectedEvent(api::identity::OnSignInChanged::Create(account_info, true));
+
+  // Add the secondary account, and verify that no event is yet fired for it.
+  AddAccount("secondary", "secondary");
+  EXPECT_TRUE(HasExpectedEvent());
+
+  // Add an event for the primary account in preparation for signing in.
+  account_info.id = "primary";
+  AddExpectedEvent(api::identity::OnSignInChanged::Create(account_info, true));
+
+  // Sign in with the primary account, and verify that both events are fired.
+  SignIn("primary", "primary");
+  EXPECT_FALSE(HasExpectedEvent());
+}
+
 // Test that signout events are fired for all known accounts when the primary
-// account signs out, firing first for the primary account and then for any
-// secondary accounts.
+// account signs out. Note that the order in which the events fire is undefined.
 IN_PROC_BROWSER_TEST_F(OnSignInChangedEventTest,
                        FireForAllAccountsOnPrimaryAccountSignOut) {
   id_api()->SetAccountStateForTesting("primary", true);
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 32acfe362fd..c41cc71a9eb 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
@@ -218,15 +218,16 @@ void IdentityGetAuthTokenFunction::OnReceivedExtensionAccountInfo(
 void IdentityGetAuthTokenFunction::StartAsyncRun() {
   // Balanced in CompleteAsyncRun
   AddRef();
-  extensions::IdentityAPI::GetFactoryInstance()
-      ->Get(GetProfile())
-      ->set_get_auth_token_function(this);
+
+  identity_api_shutdown_subscription_ =
+      extensions::IdentityAPI::GetFactoryInstance()
+          ->Get(GetProfile())
+          ->RegisterOnShutdownCallback(base::Bind(
+              &IdentityGetAuthTokenFunction::OnIdentityAPIShutdown, this));
 }
 
 void IdentityGetAuthTokenFunction::CompleteAsyncRun(bool success) {
-  extensions::IdentityAPI::GetFactoryInstance()
-      ->Get(GetProfile())
-      ->set_get_auth_token_function(nullptr);
+  identity_api_shutdown_subscription_.reset();
 
   SendResponse(success);
   Release();  // Balanced in StartAsyncRun
@@ -595,7 +596,7 @@ void IdentityGetAuthTokenFunction::OnGetTokenFailure(
 }
 #endif
 
-void IdentityGetAuthTokenFunction::Shutdown() {
+void IdentityGetAuthTokenFunction::OnIdentityAPIShutdown() {
   gaia_web_auth_flow_.reset();
   login_token_request_.reset();
   identity_manager_.reset();
diff --git a/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.h b/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.h
index 6acf9660429..e4df3372133 100644
--- a/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.h
+++ b/chromium/chrome/browser/extensions/api/identity/identity_get_auth_token_function.h
@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_GET_AUTH_TOKEN_FUNCTION_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IDENTITY_IDENTITY_GET_AUTH_TOKEN_FUNCTION_H_
 
+#include "base/callback_list.h"
 #include "chrome/browser/extensions/api/identity/gaia_web_auth_flow.h"
 #include "chrome/browser/extensions/api/identity/identity_mint_queue.h"
 #include "chrome/browser/extensions/chrome_extension_function.h"
@@ -50,7 +51,7 @@ class IdentityGetAuthTokenFunction : public ChromeAsyncExtensionFunction,
     return token_key_.get();
   }
 
-  void Shutdown();
+  void OnIdentityAPIShutdown();
 
  protected:
   ~IdentityGetAuthTokenFunction() override;
@@ -193,6 +194,10 @@ class IdentityGetAuthTokenFunction : public ChromeAsyncExtensionFunction,
   IssueAdviceInfo issue_advice_;
   std::unique_ptr<GaiaWebAuthFlow> gaia_web_auth_flow_;
 
+  // Invoked when IdentityAPI is shut down.
+  std::unique_ptr<base::CallbackList<void()>::Subscription>
+      identity_api_shutdown_subscription_;
+
   identity::mojom::IdentityManagerPtr identity_manager_;
 };
 
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 7b326e7aa3b..6d8c1f361b4 100644
--- a/chromium/chrome/browser/extensions/api/identity/web_auth_flow.cc
+++ b/chromium/chrome/browser/extensions/api/identity/web_auth_flow.cc
@@ -187,8 +187,7 @@ void WebAuthFlow::DidGetRedirectForResourceRequest(
   BeforeUrlLoaded(details.new_url);
 }
 
-void WebAuthFlow::TitleWasSet(content::NavigationEntry* entry,
-                              bool explicit_set) {
+void WebAuthFlow::TitleWasSet(content::NavigationEntry* entry) {
   if (delegate_)
     delegate_->OnAuthFlowTitleChange(base::UTF16ToUTF8(entry->GetTitle()));
 }
diff --git a/chromium/chrome/browser/extensions/api/identity/web_auth_flow.h b/chromium/chrome/browser/extensions/api/identity/web_auth_flow.h
index 1264bdca993..970e295a1dd 100644
--- a/chromium/chrome/browser/extensions/api/identity/web_auth_flow.h
+++ b/chromium/chrome/browser/extensions/api/identity/web_auth_flow.h
@@ -104,7 +104,7 @@ class WebAuthFlow : public content::NotificationObserver,
   void RenderProcessGone(base::TerminationStatus status) override;
   void DidGetRedirectForResourceRequest(
       const content::ResourceRedirectDetails& details) override;
-  void TitleWasSet(content::NavigationEntry* entry, bool explicit_set) override;
+  void TitleWasSet(content::NavigationEntry* entry) override;
   void DidStartNavigation(
       content::NavigationHandle* navigation_handle) override;
   void DidFinishNavigation(
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 5bc4932bbdd..bf12417a6e6 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
@@ -62,7 +62,7 @@ TEST_F(ImageWriterDestroyPartitionsOperationTest, EndToEnd) {
   EXPECT_CALL(manager, OnError(kDummyExtensionId, _, _, _)).Times(0);
 
   operation->PostTask(base::Bind(&Operation::Start, operation));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 } // namespace
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.cc b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.cc
index 19cfdbeae72..dce49009b74 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.cc
@@ -16,6 +16,17 @@ namespace image_writer_api = extensions::api::image_writer_private;
 
 namespace extensions {
 
+ImageWriterPrivateBaseFunction::ImageWriterPrivateBaseFunction() {}
+
+ImageWriterPrivateBaseFunction::~ImageWriterPrivateBaseFunction() {}
+
+void ImageWriterPrivateBaseFunction::OnComplete(bool success,
+                                                const std::string& error) {
+  if (!success)
+    error_ = error;
+  SendResponse(success);
+}
+
 ImageWriterPrivateWriteFromUrlFunction::
     ImageWriterPrivateWriteFromUrlFunction() {
 }
@@ -40,26 +51,14 @@ bool ImageWriterPrivateWriteFromUrlFunction::RunAsync() {
     hash = *params->options->image_hash;
   }
 
-  image_writer::OperationManager::Get(GetProfile())->StartWriteFromUrl(
-      extension_id(),
-      url,
-      hash,
-      params->storage_unit_id,
-      base::Bind(&ImageWriterPrivateWriteFromUrlFunction::OnWriteStarted,
-                 this));
+  image_writer::OperationManager::Get(GetProfile())
+      ->StartWriteFromUrl(
+          extension_id(), url, hash, params->storage_unit_id,
+          base::BindOnce(&ImageWriterPrivateWriteFromUrlFunction::OnComplete,
+                         this));
   return true;
 }
 
-void ImageWriterPrivateWriteFromUrlFunction::OnWriteStarted(
-    bool success,
-    const std::string& error) {
-  if (!success) {
-    error_ = error;
-  }
-
-  SendResponse(success);
-}
-
 ImageWriterPrivateWriteFromFileFunction::
     ImageWriterPrivateWriteFromFileFunction() {
 }
@@ -84,24 +83,14 @@ bool ImageWriterPrivateWriteFromFileFunction::RunAsync() {
           render_frame_host()->GetProcess()->GetID(), &path, &error_))
     return false;
 
-  image_writer::OperationManager::Get(GetProfile())->StartWriteFromFile(
-      extension_id(),
-      path,
-      storage_unit_id,
-      base::Bind(&ImageWriterPrivateWriteFromFileFunction::OnWriteStarted,
-                 this));
+  image_writer::OperationManager::Get(GetProfile())
+      ->StartWriteFromFile(
+          extension_id(), path, storage_unit_id,
+          base::BindOnce(&ImageWriterPrivateWriteFromFileFunction::OnComplete,
+                         this));
   return true;
 }
 
-void ImageWriterPrivateWriteFromFileFunction::OnWriteStarted(
-    bool success,
-    const std::string& error) {
-  if (!success) {
-    error_ = error;
-  }
-  SendResponse(success);
-}
-
 ImageWriterPrivateCancelWriteFunction::ImageWriterPrivateCancelWriteFunction() {
 }
 
@@ -110,22 +99,14 @@ ImageWriterPrivateCancelWriteFunction::
 }
 
 bool ImageWriterPrivateCancelWriteFunction::RunAsync() {
-  image_writer::OperationManager::Get(GetProfile())->CancelWrite(
-      extension_id(),
-      base::Bind(&ImageWriterPrivateCancelWriteFunction::OnWriteCancelled,
-                 this));
+  image_writer::OperationManager::Get(GetProfile())
+      ->CancelWrite(
+          extension_id(),
+          base::BindOnce(&ImageWriterPrivateCancelWriteFunction::OnComplete,
+                         this));
   return true;
 }
 
-void ImageWriterPrivateCancelWriteFunction::OnWriteCancelled(
-    bool success,
-    const std::string& error) {
-  if (!success) {
-    error_ = error;
-  }
-  SendResponse(success);
-}
-
 ImageWriterPrivateDestroyPartitionsFunction::
     ImageWriterPrivateDestroyPartitionsFunction() {
 }
@@ -139,25 +120,14 @@ bool ImageWriterPrivateDestroyPartitionsFunction::RunAsync() {
       image_writer_api::DestroyPartitions::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  image_writer::OperationManager::Get(GetProfile())->DestroyPartitions(
-      extension_id(),
-      params->storage_unit_id,
-      base::Bind(
-          &ImageWriterPrivateDestroyPartitionsFunction::OnDestroyComplete,
-          this));
+  image_writer::OperationManager::Get(GetProfile())
+      ->DestroyPartitions(
+          extension_id(), params->storage_unit_id,
+          base::BindOnce(
+              &ImageWriterPrivateDestroyPartitionsFunction::OnComplete, this));
   return true;
 }
 
-void ImageWriterPrivateDestroyPartitionsFunction::OnDestroyComplete(
-    bool success,
-    const std::string& error) {
-  if (!success) {
-    error_ = error;
-  }
-
-  SendResponse(success);
-}
-
 ImageWriterPrivateListRemovableStorageDevicesFunction::
   ImageWriterPrivateListRemovableStorageDevicesFunction() {
 }
diff --git a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.h b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.h
index 68b17d7ac7c..2279b935015 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/image_writer_private_api.h
@@ -10,8 +10,21 @@
 
 namespace extensions {
 
+class ImageWriterPrivateBaseFunction : public ChromeAsyncExtensionFunction {
+ public:
+  ImageWriterPrivateBaseFunction();
+
+  virtual void OnComplete(bool success, const std::string& error);
+
+ protected:
+  ~ImageWriterPrivateBaseFunction() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ImageWriterPrivateBaseFunction);
+};
+
 class ImageWriterPrivateWriteFromUrlFunction
-    : public ChromeAsyncExtensionFunction {
+    : public ImageWriterPrivateBaseFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("imageWriterPrivate.writeFromUrl",
                              IMAGEWRITER_WRITEFROMURL)
@@ -20,11 +33,10 @@ class ImageWriterPrivateWriteFromUrlFunction
  private:
   ~ImageWriterPrivateWriteFromUrlFunction() override;
   bool RunAsync() override;
-  void OnWriteStarted(bool success, const std::string& error);
 };
 
 class ImageWriterPrivateWriteFromFileFunction
-    : public ChromeAsyncExtensionFunction {
+    : public ImageWriterPrivateBaseFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("imageWriterPrivate.writeFromFile",
                              IMAGEWRITER_WRITEFROMFILE)
@@ -33,11 +45,10 @@ class ImageWriterPrivateWriteFromFileFunction
  private:
   ~ImageWriterPrivateWriteFromFileFunction() override;
   bool RunAsync() override;
-  void OnWriteStarted(bool success, const std::string& error);
 };
 
 class ImageWriterPrivateCancelWriteFunction
-    : public ChromeAsyncExtensionFunction {
+    : public ImageWriterPrivateBaseFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("imageWriterPrivate.cancelWrite",
                              IMAGEWRITER_CANCELWRITE)
@@ -46,11 +57,10 @@ class ImageWriterPrivateCancelWriteFunction
  private:
   ~ImageWriterPrivateCancelWriteFunction() override;
   bool RunAsync() override;
-  void OnWriteCancelled(bool success, const std::string& error);
 };
 
 class ImageWriterPrivateDestroyPartitionsFunction
-    : public ChromeAsyncExtensionFunction {
+    : public ImageWriterPrivateBaseFunction {
  public:
   DECLARE_EXTENSION_FUNCTION("imageWriterPrivate.destroyPartitions",
                              IMAGEWRITER_DESTROYPARTITIONS)
@@ -59,7 +69,6 @@ class ImageWriterPrivateDestroyPartitionsFunction
  private:
   ~ImageWriterPrivateDestroyPartitionsFunction() override;
   bool RunAsync() override;
-  void OnDestroyComplete(bool success, const std::string& error);
 };
 
 class ImageWriterPrivateListRemovableStorageDevicesFunction
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 295ade130f3..a345ac8a740 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
@@ -70,7 +70,7 @@ ImageWriterUtilityClient::~ImageWriterUtilityClient() = default;
 scoped_refptr<ImageWriterUtilityClient> ImageWriterUtilityClient::Create() {
   if (g_factory_for_testing)
     return g_factory_for_testing->Run();
-  return make_scoped_refptr(new ImageWriterUtilityClient());
+  return base::WrapRefCounted(new ImageWriterUtilityClient());
 }
 
 // static
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 0fedb395491..097cdfae308 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation.cc
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation.cc
@@ -108,11 +108,11 @@ void Operation::Unzip(const base::Closure& continuation) {
 
   SetStage(image_writer_api::STAGE_UNZIP);
 
-  auto unzip_helper = make_scoped_refptr(new UnzipHelper(
+  auto unzip_helper = base::MakeRefCounted<UnzipHelper>(
       task_runner(), base::Bind(&Operation::OnUnzipOpenComplete, this),
       base::Bind(&Operation::CompleteAndContinue, this, continuation),
       base::Bind(&Operation::OnUnzipFailure, this),
-      base::Bind(&Operation::OnUnzipProgress, this)));
+      base::Bind(&Operation::OnUnzipProgress, this));
   unzip_helper->Unzip(image_path_, temp_dir_.GetPath());
 }
 
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 52efeef18c4..29144f7386f 100644
--- a/chromium/chrome/browser/extensions/api/image_writer_private/operation.h
+++ b/chromium/chrome/browser/extensions/api/image_writer_private/operation.h
@@ -54,9 +54,9 @@ class OperationManager;
 // allocated/accessed on the blocking thread.  http://crbug.com/344713
 class Operation : public base::RefCountedThreadSafe<Operation> {
  public:
-  // TODO(lazyboy): Turn these into base::OnceCallback. http://crbug.com/749865.
-  typedef base::Callback<void(bool, const std::string&)> StartWriteCallback;
-  typedef base::Callback<void(bool, const std::string&)> CancelWriteCallback;
+  using StartWriteCallback = base::OnceCallback<void(bool, const std::string&)>;
+  using CancelWriteCallback =
+      base::OnceCallback<void(bool, const std::string&)>;
 
   Operation(base::WeakPtr<OperationManager> manager,
             const ExtensionId& extension_id,
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 0e007816974..10dcad0f29e 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
@@ -70,7 +70,7 @@ void OperationManager::StartWriteFromUrl(
     GURL url,
     const std::string& hash,
     const std::string& device_path,
-    const Operation::StartWriteCallback& callback) {
+    Operation::StartWriteCallback callback) {
 #if defined(OS_CHROMEOS)
   // Chrome OS can only support a single operation at a time.
   if (operations_.size() > 0) {
@@ -79,7 +79,9 @@ void OperationManager::StartWriteFromUrl(
 
   if (existing_operation != operations_.end()) {
 #endif
-    return callback.Run(false, error::kOperationAlreadyInProgress);
+
+    std::move(callback).Run(false, error::kOperationAlreadyInProgress);
+    return;
   }
 
   scoped_refptr<Operation> operation(new WriteFromUrlOperation(
@@ -94,14 +96,14 @@ void OperationManager::StartWriteFromUrl(
   operations_[extension_id] = operation;
   operation->PostTask(base::BindOnce(&Operation::Start, operation));
 
-  callback.Run(true, "");
+  std::move(callback).Run(true, "");
 }
 
 void OperationManager::StartWriteFromFile(
     const ExtensionId& extension_id,
     const base::FilePath& path,
     const std::string& device_path,
-    const Operation::StartWriteCallback& callback) {
+    Operation::StartWriteCallback callback) {
 #if defined(OS_CHROMEOS)
   // Chrome OS can only support a single operation at a time.
   if (operations_.size() > 0) {
@@ -110,7 +112,8 @@ void OperationManager::StartWriteFromFile(
 
   if (existing_operation != operations_.end()) {
 #endif
-    return callback.Run(false, error::kOperationAlreadyInProgress);
+    std::move(callback).Run(false, error::kOperationAlreadyInProgress);
+    return;
   }
 
   scoped_refptr<Operation> operation(new WriteFromFileOperation(
@@ -118,32 +121,32 @@ void OperationManager::StartWriteFromFile(
       GetAssociatedDownloadFolder()));
   operations_[extension_id] = operation;
   operation->PostTask(base::BindOnce(&Operation::Start, operation));
-  callback.Run(true, "");
+  std::move(callback).Run(true, "");
 }
 
-void OperationManager::CancelWrite(
-    const ExtensionId& extension_id,
-    const Operation::CancelWriteCallback& callback) {
+void OperationManager::CancelWrite(const ExtensionId& extension_id,
+                                   Operation::CancelWriteCallback callback) {
   Operation* existing_operation = GetOperation(extension_id);
 
   if (existing_operation == NULL) {
-    callback.Run(false, error::kNoOperationInProgress);
+    std::move(callback).Run(false, error::kNoOperationInProgress);
   } else {
     existing_operation->PostTask(
         base::BindOnce(&Operation::Cancel, existing_operation));
     DeleteOperation(extension_id);
-    callback.Run(true, "");
+    std::move(callback).Run(true, "");
   }
 }
 
 void OperationManager::DestroyPartitions(
     const ExtensionId& extension_id,
     const std::string& device_path,
-    const Operation::StartWriteCallback& callback) {
+    Operation::StartWriteCallback callback) {
   OperationMap::iterator existing_operation = operations_.find(extension_id);
 
   if (existing_operation != operations_.end()) {
-    return callback.Run(false, error::kOperationAlreadyInProgress);
+    std::move(callback).Run(false, error::kOperationAlreadyInProgress);
+    return;
   }
 
   scoped_refptr<Operation> operation(new DestroyPartitionsOperation(
@@ -151,7 +154,7 @@ void OperationManager::DestroyPartitions(
       GetAssociatedDownloadFolder()));
   operations_[extension_id] = operation;
   operation->PostTask(base::BindOnce(&Operation::Start, operation));
-  callback.Run(true, "");
+  std::move(callback).Run(true, "");
 }
 
 void OperationManager::OnProgress(const ExtensionId& extension_id,
@@ -270,11 +273,11 @@ OperationManager* OperationManager::Get(content::BrowserContext* context) {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<OperationManager>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_operation_manager_factory = LAZY_INSTANCE_INITIALIZER;
 
 BrowserContextKeyedAPIFactory<OperationManager>*
 OperationManager::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_operation_manager_factory.Pointer();
 }
 
 
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 56257fa4fb9..9debbffd6f8 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
@@ -52,22 +52,22 @@ class OperationManager : public BrowserContextKeyedAPI,
                          GURL url,
                          const std::string& hash,
                          const std::string& device_path,
-                         const Operation::StartWriteCallback& callback);
+                         Operation::StartWriteCallback callback);
 
   // Starts a WriteFromFile operation.
   void StartWriteFromFile(const ExtensionId& extension_id,
                           const base::FilePath& path,
                           const std::string& device_path,
-                          const Operation::StartWriteCallback& callback);
+                          Operation::StartWriteCallback callback);
 
   // Cancels the extensions current operation if any.
   void CancelWrite(const ExtensionId& extension_id,
-                   const Operation::CancelWriteCallback& callback);
+                   Operation::CancelWriteCallback callback);
 
   // Starts a write that removes the partition table.
   void DestroyPartitions(const ExtensionId& extension_id,
                          const std::string& device_path,
-                         const Operation::StartWriteCallback& callback);
+                         Operation::StartWriteCallback callback);
 
   // Callback for progress events.
   virtual void OnProgress(const ExtensionId& extension_id,
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 d020f25e12b..22f6193100d 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
@@ -11,35 +11,12 @@
 #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/extension_service.h"
-#include "chrome/browser/extensions/extension_system_factory.h"
-#include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/test/base/testing_profile.h"
-#include "extensions/browser/event_router.h"
-#include "extensions/browser/event_router_factory.h"
+#include "extensions/browser/test_event_router.h"
 
 namespace extensions {
 namespace image_writer {
 
-// A fake for the EventRouter. If tests require monitoring of interaction with
-// the event router put the logic here.
-class FakeEventRouter : public extensions::EventRouter {
- public:
-  explicit FakeEventRouter(Profile* profile) : EventRouter(profile, NULL) {}
-
-  void DispatchEventToExtension(
-      const std::string& extension_id,
-      std::unique_ptr<extensions::Event> event) override {
-    // Do nothing with the event as no tests currently care.
-  }
-};
-
-// FakeEventRouter factory function
-std::unique_ptr<KeyedService> FakeEventRouterFactoryFunction(
-    content::BrowserContext* context) {
-  return base::MakeUnique<FakeEventRouter>(static_cast<Profile*>(context));
-}
-
 namespace {
 
 class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
@@ -64,9 +41,7 @@ class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
 
   void SetUp() override {
     ImageWriterUnitTestBase::SetUp();
-    event_router_ = static_cast<FakeEventRouter*>(
-        extensions::EventRouterFactory::GetInstance()->SetTestingFactoryAndUse(
-            &test_profile_, &FakeEventRouterFactoryFunction));
+    CreateAndUseTestEventRouter(&test_profile_);
   }
 
   bool started_;
@@ -78,7 +53,6 @@ class ImageWriterOperationManagerTest : public ImageWriterUnitTestBase {
   std::string cancel_error_;
 
   TestingProfile test_profile_;
-  FakeEventRouter* event_router_;
 };
 
 TEST_F(ImageWriterOperationManagerTest, WriteFromFile) {
@@ -104,7 +78,7 @@ TEST_F(ImageWriterOperationManagerTest, WriteFromFile) {
   EXPECT_TRUE(cancel_success_);
   EXPECT_EQ("", cancel_error_);
 
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 TEST_F(ImageWriterOperationManagerTest, DestroyPartitions) {
@@ -129,7 +103,7 @@ TEST_F(ImageWriterOperationManagerTest, DestroyPartitions) {
   EXPECT_TRUE(cancel_success_);
   EXPECT_EQ("", cancel_error_);
 
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 } // namespace
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 2e8654ee0e4..f2f030df622 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
@@ -255,7 +255,7 @@ TEST_F(ImageWriterOperationTest, VerifyFileFailure) {
 
   operation_->Start();
   operation_->VerifyWrite(base::Bind(&base::DoNothing));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 #endif  // !defined(OS_CHROMEOS)
 
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 a19da48acad..432640c08fb 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
@@ -182,7 +182,7 @@ scoped_refptr<ImageWriterUtilityClient> CreateFakeImageWriterUtilityClient(
     ImageWriterTestUtils* utils) {
   auto* client = new FakeImageWriterClient();
   utils->OnUtilityClientCreated(client);
-  return make_scoped_refptr(client);
+  return base::WrapRefCounted(client);
 }
 #endif  // !defined(OS_CHROMEOS)
 
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 2a79bf4506d..e8a4f5a9209 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
@@ -56,7 +56,7 @@ TEST_F(ImageWriterFromFileTest, InvalidFile) {
                       error::kImageInvalid)).Times(1);
 
   op->PostTask(base::BindOnce(&Operation::Start, op));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 // Runs the entire WriteFromFile operation.
@@ -103,7 +103,7 @@ TEST_F(ImageWriterFromFileTest, WriteFromFileEndToEnd) {
   EXPECT_CALL(manager_, OnError(kDummyExtensionId, _, _, _)).Times(0);
 
   op->PostTask(base::BindOnce(&Operation::Start, op));
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 }  // namespace image_writer
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 30d91fc504f..a8b7a3f3b04 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
@@ -137,7 +137,7 @@ TEST_F(ImageWriterWriteFromUrlOperationTest, SelectTargetWithoutExtension) {
             operation->GetImagePath().BaseName().value());
 
   operation->Cancel();
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 TEST_F(ImageWriterWriteFromUrlOperationTest, SelectTargetWithExtension) {
@@ -182,7 +182,7 @@ TEST_F(ImageWriterWriteFromUrlOperationTest, DownloadFile) {
 
   operation->Download(runloop.QuitClosure());
   runloop.Run();
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 
   EXPECT_TRUE(base::ContentsEqual(test_utils_.GetImagePath(),
                                   operation->GetImagePath()));
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 6b60ecd81aa..f41a3b19c00 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
@@ -27,6 +27,12 @@ using input_method::InputMethodEngineBase;
 namespace {
 const char kErrorEngineNotAvailable[] = "Engine is not available";
 const char kErrorSetKeyEventsFail[] = "Could not send key events";
+
+bool IsKeyboardRestricted() {
+  const keyboard::KeyboardConfig config = keyboard::GetKeyboardConfig();
+  return !(config.spell_check && config.auto_complete && config.auto_correct &&
+           config.voice_input && config.handwriting);
+}
 }
 namespace ui {
 
@@ -201,7 +207,9 @@ std::string ImeObserver::ConvertInputContextType(
   // This is a hack, but tricking the virtual keyboard to think the
   // current input context is password will disable all keyboard features
   // that are not supported in restricted keyboard mode.
-  if (keyboard::GetKeyboardRestricted() &&
+  // TODO(oka): Remove this hack once VK extension starts to honor the
+  // virtualKeyboardPrivate.GetKeyboardConfig parameters.
+  if (IsKeyboardRestricted() &&
       input_context.type != ui::TEXT_INPUT_TYPE_TELEPHONE &&
       input_context.type != ui::TEXT_INPUT_TYPE_NUMBER) {
     return "password";
@@ -236,19 +244,19 @@ std::string ImeObserver::ConvertInputContextType(
 
 bool ImeObserver::ConvertInputContextAutoCorrect(
     ui::IMEEngineHandlerInterface::InputContext input_context) {
-  return !keyboard::GetKeyboardRestricted() &&
+  return keyboard::GetKeyboardConfig().auto_correct &&
          !(input_context.flags & ui::TEXT_INPUT_FLAG_AUTOCORRECT_OFF);
 }
 
 bool ImeObserver::ConvertInputContextAutoComplete(
     ui::IMEEngineHandlerInterface::InputContext input_context) {
-  return !keyboard::GetKeyboardRestricted() &&
+  return keyboard::GetKeyboardConfig().auto_complete &&
          !(input_context.flags & ui::TEXT_INPUT_FLAG_AUTOCOMPLETE_OFF);
 }
 
 bool ImeObserver::ConvertInputContextSpellCheck(
     ui::IMEEngineHandlerInterface::InputContext input_context) {
-  return !keyboard::GetKeyboardRestricted() &&
+  return keyboard::GetKeyboardConfig().spell_check &&
          !(input_context.flags & ui::TEXT_INPUT_FLAG_SPELLCHECK_OFF);
 }
 
@@ -425,13 +433,12 @@ void InputImeAPI::Shutdown() {
   registrar_.RemoveAll();
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<InputImeAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<InputImeAPI>>::
+    DestructorAtExit g_input_ime_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<InputImeAPI>* InputImeAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_input_ime_factory.Pointer();
 }
 
 InputImeEventRouter* GetInputImeEventRouter(Profile* profile) {
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 fdac6815148..67b3a21b24f 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
@@ -12,6 +12,7 @@
 #include <utility>
 #include <vector>
 
+#include "base/feature_list.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
@@ -24,6 +25,7 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/language_settings_private/language_settings_private_delegate.h"
 #include "chrome/browser/extensions/api/language_settings_private/language_settings_private_delegate_factory.h"
+#include "chrome/browser/language/language_model_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
@@ -31,8 +33,11 @@
 #include "chrome/browser/translate/translate_service.h"
 #include "chrome/common/extensions/api/language_settings_private.h"
 #include "chrome/common/pref_names.h"
+#include "components/language/core/browser/language_model.h"
 #include "components/spellcheck/common/spellcheck_common.h"
 #include "components/translate/core/browser/translate_download_manager.h"
+#include "components/translate/core/browser/translate_prefs.h"
+#include "components/translate/core/common/translate_util.h"
 #include "third_party/icu/source/i18n/unicode/coll.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_collator.h"
@@ -236,7 +241,14 @@ LanguageSettingsPrivateGetLanguageListFunction::Run() {
       language.supports_ui.reset(new bool(true));
     if (spellcheck_language_set.count(pair.first) > 0)
       language.supports_spellcheck.reset(new bool(true));
-    if (translate_language_set.count(pair.first) > 0)
+
+    std::string supports_translate_code = pair.first;
+    if (base::FeatureList::IsEnabled(translate::kImprovedLanguageSettings)) {
+      // Extract the base language: if the base language can be translated, then
+      // even the regional one should be marked as such.
+      translate::ToTranslateLanguageSynonym(&supports_translate_code);
+    }
+    if (translate_language_set.count(supports_translate_code) > 0)
       language.supports_translate.reset(new bool(true));
 
     language_list->Append(language.ToValue());
@@ -265,14 +277,15 @@ LanguageSettingsPrivateEnableLanguageFunction::Run() {
 
   std::vector<std::string> languages;
   translate_prefs->GetLanguageList(&languages);
+  std::string chrome_language = language_code;
+  translate::ToChromeLanguageSynonym(&chrome_language);
 
-  if (base::ContainsValue(languages, language_code)) {
-    LOG(ERROR) << "Language " << language_code << " already enabled";
+  if (base::ContainsValue(languages, chrome_language)) {
+    LOG(ERROR) << "Language " << chrome_language << " already enabled";
     return RespondNow(NoArguments());
   }
 
-  languages.push_back(parameters->language_code);
-  translate_prefs->UpdateLanguageList(languages);
+  translate_prefs->AddToLanguageList(language_code, /*force_blocked=*/false);
 
   return RespondNow(NoArguments());
 }
@@ -298,15 +311,47 @@ LanguageSettingsPrivateDisableLanguageFunction::Run() {
 
   std::vector<std::string> languages;
   translate_prefs->GetLanguageList(&languages);
+  std::string chrome_language = language_code;
+  translate::ToChromeLanguageSynonym(&chrome_language);
 
-  auto it = std::find(languages.begin(), languages.end(), language_code);
+  auto it = std::find(languages.begin(), languages.end(), chrome_language);
   if (it == languages.end()) {
-    LOG(ERROR) << "Language " << language_code << " not enabled";
+    LOG(ERROR) << "Language " << chrome_language << " not enabled";
     return RespondNow(NoArguments());
   }
 
-  languages.erase(it);
-  translate_prefs->UpdateLanguageList(languages);
+  translate_prefs->RemoveFromLanguageList(language_code);
+
+  return RespondNow(NoArguments());
+}
+
+LanguageSettingsPrivateSetEnableTranslationForLanguageFunction::
+    LanguageSettingsPrivateSetEnableTranslationForLanguageFunction()
+    : chrome_details_(this) {}
+
+LanguageSettingsPrivateSetEnableTranslationForLanguageFunction::
+    ~LanguageSettingsPrivateSetEnableTranslationForLanguageFunction() {}
+
+ExtensionFunction::ResponseAction
+LanguageSettingsPrivateSetEnableTranslationForLanguageFunction::Run() {
+  const std::unique_ptr<
+      language_settings_private::SetEnableTranslationForLanguage::Params>
+      parameters = language_settings_private::SetEnableTranslationForLanguage::
+          Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(parameters.get());
+  const std::string& language_code = parameters->language_code;
+  // True if translation enabled, false if disabled.
+  const bool enable = parameters->enable;
+
+  std::unique_ptr<translate::TranslatePrefs> translate_prefs =
+      ChromeTranslateClient::CreateTranslatePrefs(
+          chrome_details_.GetProfile()->GetPrefs());
+
+  if (enable) {
+    translate_prefs->UnblockLanguage(language_code);
+  } else {
+    translate_prefs->BlockLanguage(language_code);
+  }
 
   return RespondNow(NoArguments());
 }
@@ -438,9 +483,12 @@ LanguageSettingsPrivateGetTranslateTargetLanguageFunction::
 
 ExtensionFunction::ResponseAction
 LanguageSettingsPrivateGetTranslateTargetLanguageFunction::Run() {
+  Profile* profile = chrome_details_.GetProfile();
+  language::LanguageModel* language_model =
+      LanguageModelFactory::GetInstance()->GetForBrowserContext(profile);
   return RespondNow(OneArgument(
       base::MakeUnique<base::Value>(TranslateService::GetTargetLanguage(
-          chrome_details_.GetProfile()->GetPrefs()))));
+          profile->GetPrefs(), language_model))));
 }
 
 #if defined(OS_CHROMEOS)
diff --git a/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.h b/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.h
index 662298d6e7d..036e33a5d0b 100644
--- a/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.h
+++ b/chromium/chrome/browser/extensions/api/language_settings_private/language_settings_private_api.h
@@ -70,6 +70,28 @@ class LanguageSettingsPrivateDisableLanguageFunction
   DISALLOW_COPY_AND_ASSIGN(LanguageSettingsPrivateDisableLanguageFunction);
 };
 
+// Implements the languageSettingsPrivate.setEnableTranslationForLanguage
+// method.
+class LanguageSettingsPrivateSetEnableTranslationForLanguageFunction
+    : public UIThreadExtensionFunction {
+ public:
+  LanguageSettingsPrivateSetEnableTranslationForLanguageFunction();
+  DECLARE_EXTENSION_FUNCTION(
+      "languageSettingsPrivate.setEnableTranslationForLanguage",
+      LANGUAGESETTINGSPRIVATE_SETENABLETRANSLATIONFORLANGUAGE)
+
+ protected:
+  ~LanguageSettingsPrivateSetEnableTranslationForLanguageFunction() override;
+
+  // ExtensionFunction overrides.
+  ResponseAction Run() override;
+
+ private:
+  ChromeExtensionFunctionDetails chrome_details_;
+  DISALLOW_COPY_AND_ASSIGN(
+      LanguageSettingsPrivateSetEnableTranslationForLanguageFunction);
+};
+
 // Implements the languageSettingsPrivate.getSpellcheckDictionaryStatuses
 // method.
 class LanguageSettingsPrivateGetSpellcheckDictionaryStatusesFunction
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
index 2c68152d32f..3817c0f25c2 100644
--- a/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.cc
+++ b/chromium/chrome/browser/extensions/api/launcher_page/launcher_page_api.cc
@@ -16,12 +16,12 @@
 namespace extensions {
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<LauncherPageAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_launcher_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<LauncherPageAPI>*
 LauncherPageAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_launcher_api_factory.Pointer();
 }
 
 LauncherPageAPI::LauncherPageAPI(content::BrowserContext* context)
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 73fd31913c3..038ee70fd61 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
@@ -21,7 +21,6 @@
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
-#include "chrome/common/extensions/chrome_utility_extensions_messages.h"
 #include "chrome/common/extensions/extension_metrics.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/web_application_info.h"
diff --git a/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc b/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc
index b7ac56b46a7..4d28c195fff 100644
--- a/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc
+++ b/chromium/chrome/browser/extensions/api/mdns/mdns_api.cc
@@ -57,13 +57,12 @@ MDnsAPI* MDnsAPI::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<MDnsAPI>::Get(context);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<MDnsAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<MDnsAPI>>::
+    DestructorAtExit g_mdns_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<MDnsAPI>* MDnsAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_mdns_api_factory.Pointer();
 }
 
 void MDnsAPI::SetDnsSdRegistryForTesting(DnsSdRegistry* dns_sd_registry) {
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 4a9ea22a56c..97fa36f65db 100644
--- a/chromium/chrome/browser/extensions/api/mdns/mdns_api_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/mdns/mdns_api_unittest.cc
@@ -23,6 +23,7 @@
 #include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -364,15 +365,15 @@ TEST_F(MDnsAPITest, ExtensionRespectsWhitelist) {
         .Times(0);
     EventRouter::Get(browser_context())
         ->AddFilteredEventListener(api::mdns::OnServiceList::kEventName,
-                                   render_process_host(), kExtId, filter,
-                                   false);
+                                   render_process_host(), kExtId, base::nullopt,
+                                   filter, false);
 
     EXPECT_CALL(*dns_sd_registry(), UnregisterDnsSdListener("_trex._tcp.local"))
         .Times(0);
     EventRouter::Get(browser_context())
         ->RemoveFilteredEventListener(api::mdns::OnServiceList::kEventName,
-                                      render_process_host(), kExtId, filter,
-                                      false);
+                                      render_process_host(), kExtId,
+                                      base::nullopt, filter, false);
   }
   {
     base::DictionaryValue filter;
@@ -384,15 +385,15 @@ TEST_F(MDnsAPITest, ExtensionRespectsWhitelist) {
                 RegisterDnsSdListener("_testing._tcp.local"));
     EventRouter::Get(browser_context())
         ->AddFilteredEventListener(api::mdns::OnServiceList::kEventName,
-                                   render_process_host(), kExtId, filter,
-                                   false);
+                                   render_process_host(), kExtId, base::nullopt,
+                                   filter, false);
 
     EXPECT_CALL(*dns_sd_registry(),
                 UnregisterDnsSdListener("_testing._tcp.local"));
     EventRouter::Get(browser_context())
         ->RemoveFilteredEventListener(api::mdns::OnServiceList::kEventName,
-                                      render_process_host(), kExtId, filter,
-                                      false);
+                                      render_process_host(), kExtId,
+                                      base::nullopt, filter, false);
   }
 }
 
@@ -408,15 +409,17 @@ TEST_F(MDnsAPITest, PlatformAppsNotSubjectToWhitelist) {
   ASSERT_TRUE(dns_sd_registry());
   // Test that the extension is able to listen to a non-whitelisted service
   EXPECT_CALL(*dns_sd_registry(), RegisterDnsSdListener("_trex._tcp.local"));
+
   EventRouter::Get(browser_context())
       ->AddFilteredEventListener(api::mdns::OnServiceList::kEventName,
-                                 render_process_host(), kExtId, filter, false);
+                                 render_process_host(), kExtId, base::nullopt,
+                                 filter, false);
 
   EXPECT_CALL(*dns_sd_registry(), UnregisterDnsSdListener("_trex._tcp.local"));
   EventRouter::Get(browser_context())
       ->RemoveFilteredEventListener(api::mdns::OnServiceList::kEventName,
-                                    render_process_host(), kExtId, filter,
-                                    false);
+                                    render_process_host(), kExtId,
+                                    base::nullopt, filter, false);
 }
 
 }  // namespace extensions
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 a6ada3fa9e3..c6f6cfe7eca 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
@@ -314,12 +314,12 @@ void MediaGalleriesEventRouter::Shutdown() {
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_media_galleries_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>*
 MediaGalleriesEventRouter::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_media_galleries_api_factory.Pointer();
 }
 
 // static
diff --git a/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc b/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
index a37f3e39686..a810a65de0c 100644
--- a/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
@@ -27,6 +27,7 @@
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/common/chrome_paths.h"
+#include "components/nacl/common/features.h"
 #include "components/storage_monitor/storage_info.h"
 #include "components/storage_monitor/storage_monitor.h"
 #include "content/public/browser/web_contents.h"
@@ -39,20 +40,12 @@
 #include "media/base/test_data_util.h"
 #include "media/media_features.h"
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
-#include "chrome/browser/media_galleries/fileapi/picasa_finder.h"
-#include "chrome/common/media_galleries/picasa_test_util.h"
-#include "chrome/common/media_galleries/picasa_types.h"
-#include "chrome/common/media_galleries/pmp_test_util.h"
-#endif
-
 #if defined(OS_MACOSX)
 #include "base/mac/foundation_util.h"
 #include "base/strings/sys_string_conversions.h"
-#include "chrome/browser/media_galleries/fileapi/iapps_finder_impl.h"
 #endif  // OS_MACOSX
 
-#if !defined(DISABLE_NACL)
+#if BUILDFLAG(ENABLE_NACL)
 #include "base/command_line.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
@@ -215,39 +208,6 @@ class MediaGalleriesPlatformAppBrowserTest : public PlatformAppBrowserTest {
         fake_gallery_temp_dir_.GetPath().Append(source_path.BaseName())));
   }
 
-#if defined(OS_WIN) || defined(OS_MACOSX)
-  void PopulatePicasaTestData(const base::FilePath& picasa_app_data_root) {
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
-    base::FilePath picasa_database_path =
-        picasa::MakePicasaDatabasePath(picasa_app_data_root);
-    base::FilePath picasa_temp_dir_path =
-        picasa_database_path.DirName().AppendASCII(picasa::kPicasaTempDirName);
-    ASSERT_TRUE(base::CreateDirectory(picasa_database_path));
-    ASSERT_TRUE(base::CreateDirectory(picasa_temp_dir_path));
-
-    // Create fake folder directories.
-    base::FilePath folders_root =
-        ensure_media_directories_exists_->GetFakePicasaFoldersRootPath();
-    base::FilePath fake_folder_1 = folders_root.AppendASCII("folder1");
-    base::FilePath fake_folder_2 = folders_root.AppendASCII("folder2");
-    ASSERT_TRUE(base::CreateDirectory(fake_folder_1));
-    ASSERT_TRUE(base::CreateDirectory(fake_folder_2));
-
-    // Write folder and album contents.
-    picasa::WriteTestAlbumTable(
-        picasa_database_path, fake_folder_1, fake_folder_2);
-    picasa::WriteTestAlbumsImagesIndex(fake_folder_1, fake_folder_2);
-
-    base::FilePath test_jpg_path = GetCommonDataDir().AppendASCII("test.jpg");
-    ASSERT_TRUE(base::CopyFile(
-        test_jpg_path, fake_folder_1.AppendASCII("InBoth.jpg")));
-    ASSERT_TRUE(base::CopyFile(
-        test_jpg_path, fake_folder_1.AppendASCII("InSecondAlbumOnly.jpg")));
-    ASSERT_TRUE(base::CopyFile(
-        test_jpg_path, fake_folder_2.AppendASCII("InFirstAlbumOnly.jpg")));
-  }
-#endif  // defined(OS_WIN) || defined(OS_MACOSX)
-
   base::FilePath GetCommonDataDir() const {
     return test_data_dir_.AppendASCII("api_test")
                          .AppendASCII("media_galleries")
@@ -282,7 +242,7 @@ class MediaGalleriesPlatformAppBrowserTest : public PlatformAppBrowserTest {
       ensure_media_directories_exists_;
 };
 
-#if !defined(DISABLE_NACL)
+#if BUILDFLAG(ENABLE_NACL)
 class MediaGalleriesPlatformAppPpapiTest
     : public MediaGalleriesPlatformAppBrowserTest {
  protected:
@@ -333,7 +293,7 @@ IN_PROC_BROWSER_TEST_F(MediaGalleriesPlatformAppPpapiTest, SendFilesystem) {
   ASSERT_TRUE(result) << message_;
 }
 
-#endif  // !defined(DISABLE_NACL)
+#endif  // BUILDFLAG(ENABLE_NACL)
 
 // Test is flaky, it fails on certain bots, namely WinXP Tests(1) and Linux
 // (dbg)(1)(32).  See crbug.com/354425.
@@ -410,46 +370,6 @@ IN_PROC_BROWSER_TEST_F(MediaGalleriesPlatformAppBrowserTest,
   DetachFakeDevice();
 }
 
-// These two tests are flaky, they time out frequently on Win7 bots. See
-// crbug.com/567212.
-#if defined(OS_WIN)
-#define MAYBE_PicasaDefaultLocation DISABLED_PicasaDefaultLocation
-#define MAYBE_PicasaCustomLocation DISABLED_PicasaCustomLocation
-#else
-#define MAYBE_PicasaDefaultLocation PicasaDefaultLocation
-#define MAYBE_PicasaCustomLocation PicasaCustomLocation
-#endif
-#if defined(OS_WIN)|| defined(OS_MACOSX)
-IN_PROC_BROWSER_TEST_F(MediaGalleriesPlatformAppBrowserTest,
-                       MAYBE_PicasaDefaultLocation) {
-#if defined(OS_WIN)
-  PopulatePicasaTestData(
-      ensure_media_directories_exists()->GetFakeLocalAppDataPath());
-#elif defined(OS_MACOSX)
-  PopulatePicasaTestData(
-      ensure_media_directories_exists()->GetFakeAppDataPath());
-#endif
-
-  base::ListValue custom_args;
-  custom_args.AppendInteger(test_jpg_size());
-  ASSERT_TRUE(RunMediaGalleriesTestWithArg("picasa", custom_args)) << message_;
-}
-
-IN_PROC_BROWSER_TEST_F(MediaGalleriesPlatformAppBrowserTest,
-                       MAYBE_PicasaCustomLocation) {
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  base::ScopedTempDir custom_picasa_app_data_root;
-  ASSERT_TRUE(custom_picasa_app_data_root.CreateUniqueTempDir());
-  ensure_media_directories_exists()->SetCustomPicasaAppDataPath(
-      custom_picasa_app_data_root.GetPath());
-  PopulatePicasaTestData(custom_picasa_app_data_root.GetPath());
-
-  base::ListValue custom_args;
-  custom_args.AppendInteger(test_jpg_size());
-  ASSERT_TRUE(RunMediaGalleriesTestWithArg("picasa", custom_args)) << message_;
-}
-#endif  // defined(OS_WIN) || defined(OS_MACOSX)
-
 IN_PROC_BROWSER_TEST_F(MediaGalleriesPlatformAppBrowserTest, ToURL) {
   RemoveAllGalleries();
   MediaGalleryPrefId pref_id;
diff --git a/chromium/chrome/browser/extensions/api/messaging/DEPS b/chromium/chrome/browser/extensions/api/messaging/DEPS
new file mode 100644
index 00000000000..06590ef7e73
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/messaging/DEPS
@@ -0,0 +1,8 @@
+specific_include_rules = {
+  "native_message_host_chromeos.cc": [
+    # TODO(erg): This allows us to switch between mus and classic ash/ozone as
+    # targets. It should be removed when support for classic ash is removed;
+    # which means that remoting never touches ozone.
+    "+ui/ozone/public/ozone_platform.h",
+  ]
+}
diff --git a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc
index 39818de0a6d..4fa51a6661c 100644
--- a/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc
+++ b/chromium/chrome/browser/extensions/api/messaging/incognito_connectability.cc
@@ -291,12 +291,12 @@ bool IncognitoConnectability::IsInMap(const Extension* extension,
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<IncognitoConnectability>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_incognito_connectability_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<IncognitoConnectability>*
 IncognitoConnectability::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_incognito_connectability_factory.Pointer();
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc b/chromium/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc
index 0c166c92619..3c9932703ad 100644
--- a/chromium/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc
+++ b/chromium/chrome/browser/extensions/api/messaging/native_message_host_chromeos.cc
@@ -12,6 +12,7 @@
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
@@ -29,9 +30,14 @@
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/it2me/it2me_native_messaging_host.h"
 #include "remoting/host/policy_watcher.h"
+#include "ui/events/system_input_injector.h"
 #include "ui/gfx/native_widget_types.h"
 #include "url/gurl.h"
 
+#if defined(USE_OZONE)
+#include "ui/ozone/public/ozone_platform.h"
+#endif
+
 namespace extensions {
 
 namespace {
@@ -96,18 +102,44 @@ struct BuiltInHost {
   std::unique_ptr<NativeMessageHost> (*create_function)();
 };
 
+#if defined(USE_OZONE)
+class OzoneSystemInputInjectorAdaptor : public ui::SystemInputInjectorFactory {
+ public:
+  std::unique_ptr<ui::SystemInputInjector> CreateSystemInputInjector()
+      override {
+    return ui::OzonePlatform::GetInstance()->CreateSystemInputInjector();
+  }
+};
+
+base::LazyInstance<OzoneSystemInputInjectorAdaptor>::Leaky
+    g_ozone_system_input_injector_adaptor = LAZY_INSTANCE_INITIALIZER;
+#endif
+
+ui::SystemInputInjectorFactory* GetInputInjector() {
+  ui::SystemInputInjectorFactory* system = ui::GetSystemInputInjectorFactory();
+  if (system)
+    return system;
+
+#if defined(USE_OZONE)
+  return g_ozone_system_input_injector_adaptor.Pointer();
+#endif
+
+  return nullptr;
+}
+
 std::unique_ptr<NativeMessageHost> CreateIt2MeHost() {
   std::unique_ptr<remoting::It2MeHostFactory> host_factory(
       new remoting::It2MeHostFactory());
   std::unique_ptr<remoting::ChromotingHostContext> context =
       remoting::ChromotingHostContext::CreateForChromeOS(
-          make_scoped_refptr(g_browser_process->system_request_context()),
+          base::WrapRefCounted(g_browser_process->system_request_context()),
           content::BrowserThread::GetTaskRunnerForThread(
               content::BrowserThread::IO),
           content::BrowserThread::GetTaskRunnerForThread(
               content::BrowserThread::UI),
           base::CreateSingleThreadTaskRunnerWithTraits(
-              {base::MayBlock(), base::TaskPriority::BACKGROUND}));
+              {base::MayBlock(), base::TaskPriority::BACKGROUND}),
+          GetInputInjector());
   std::unique_ptr<remoting::PolicyWatcher> policy_watcher =
       remoting::PolicyWatcher::CreateWithPolicyService(
           g_browser_process->policy_service());
diff --git a/chromium/chrome/browser/extensions/api/messaging/native_message_process_host.h b/chromium/chrome/browser/extensions/api/messaging/native_message_process_host.h
index 2ddef67c509..b7355714661 100644
--- a/chromium/chrome/browser/extensions/api/messaging/native_message_process_host.h
+++ b/chromium/chrome/browser/extensions/api/messaging/native_message_process_host.h
@@ -6,9 +6,9 @@
 #define CHROME_BROWSER_EXTENSIONS_API_MESSAGING_NATIVE_MESSAGE_PROCESS_HOST_H_
 
 #include <memory>
-#include <queue>
 #include <string>
 
+#include "base/containers/queue.h"
 #include "base/files/file.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
@@ -124,7 +124,7 @@ class NativeMessageProcessHost : public NativeMessageHost {
   std::string incoming_data_;
 
   // Queue for outgoing messages.
-  std::queue<scoped_refptr<net::IOBufferWithSize> > write_queue_;
+  base::queue<scoped_refptr<net::IOBufferWithSize>> write_queue_;
 
   // The message that's currently being sent.
   scoped_refptr<net::DrainableIOBuffer> current_write_buffer_;
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 2ec7a5413cf..642d7a17eea 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
@@ -165,6 +165,14 @@ class TestNetworkingPrivateDelegate : public NetworkingPrivateDelegate {
     VoidResult(success_callback, failure_callback);
   }
 
+  void SelectCellularMobileNetwork(
+      const std::string& guid,
+      const std::string& nework_id,
+      const VoidCallback& success_callback,
+      const FailureCallback& failure_callback) override {
+    VoidResult(success_callback, failure_callback);
+  }
+
   // Synchronous methods
   std::unique_ptr<base::ListValue> GetEnabledNetworkTypes() override {
     std::unique_ptr<base::ListValue> result;
@@ -206,15 +214,15 @@ class TestNetworkingPrivateDelegate : public NetworkingPrivateDelegate {
     return !fail_;
   }
 
-  bool RequestScan() override {
-    scan_requested_.push_back(true);
+  bool RequestScan(const std::string& type) override {
+    scan_requested_.push_back(type);
     return !fail_;
   }
 
   void set_fail(bool fail) { fail_ = fail; }
   bool GetEnabled(const std::string& type) { return enabled_[type]; }
   bool GetDisabled(const std::string& type) { return disabled_[type]; }
-  size_t GetScanRequested() { return scan_requested_.size(); }
+  const std::vector<std::string>& GetScanRequested() { return scan_requested_; }
 
   void DictionaryResult(const std::string& guid,
                         const DictionaryCallback& success_callback,
@@ -261,7 +269,7 @@ class TestNetworkingPrivateDelegate : public NetworkingPrivateDelegate {
   bool fail_;
   std::map<std::string, bool> enabled_;
   std::map<std::string, bool> disabled_;
-  std::vector<bool> scan_requested_;
+  std::vector<std::string> scan_requested_;
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkingPrivateDelegate);
 };
@@ -373,7 +381,7 @@ class NetworkingPrivateApiTest : public ExtensionApiTest {
     return networking_private_delegate_->GetDisabled(type);
   }
 
-  size_t GetScanRequested() {
+  const std::vector<std::string>& GetScanRequested() {
     return networking_private_delegate_->GetScanRequested();
   }
 
@@ -488,7 +496,10 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, DisableNetworkType) {
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, RequestNetworkScan) {
   EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScan")) << message_;
-  EXPECT_EQ(1u, GetScanRequested());
+  const std::vector<std::string>& scan_requested = GetScanRequested();
+  ASSERT_EQ(2u, scan_requested.size());
+  EXPECT_EQ("", scan_requested[0]);
+  EXPECT_EQ("Cellular", scan_requested[1]);
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, StartConnect) {
@@ -535,6 +546,10 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, SetCellularSimState) {
   EXPECT_TRUE(RunNetworkingSubtest("setCellularSimState")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, SelectCellularMobileNetwork) {
+  EXPECT_TRUE(RunNetworkingSubtest("selectCellularMobileNetwork")) << message_;
+}
+
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetGlobalPolicy) {
   EXPECT_TRUE(RunNetworkingSubtest("getGlobalPolicy")) << message_;
 }
@@ -642,6 +657,11 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, SetCellularSimState) {
   EXPECT_FALSE(RunNetworkingSubtest("setCellularSimState")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail,
+                       SelectCellularMobileNetwork) {
+  EXPECT_FALSE(RunNetworkingSubtest("selectCellularMobileNetwork")) << message_;
+}
+
 #endif // defined(OS_WIN)
 
 }  // namespace extensions
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 10c2cab24d8..7a0c2a93298 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
@@ -10,6 +10,7 @@
 #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 "chrome/browser/browser_process.h"
@@ -31,7 +32,9 @@
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_certificate_handler.h"
 #include "chromeos/network/network_handler.h"
+#include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/network_type_pattern.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "components/onc/onc_constants.h"
@@ -53,6 +56,7 @@
 #include "extensions/browser/api/networking_private/networking_private_delegate_factory.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/switches.h"
+#include "extensions/common/value_builder.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -67,8 +71,6 @@ using testing::Return;
 using testing::_;
 
 using chromeos::CryptohomeClient;
-using chromeos::DBUS_METHOD_CALL_SUCCESS;
-using chromeos::DBusMethodCallStatus;
 using chromeos::DBusThreadManager;
 using chromeos::NetworkPortalDetector;
 using chromeos::NetworkPortalDetectorTestImpl;
@@ -212,13 +214,6 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
   }
 
-  static void AssignString(std::string* out,
-                           DBusMethodCallStatus call_status,
-                           const std::string& result) {
-    CHECK_EQ(call_status, DBUS_METHOD_CALL_SUCCESS);
-    *out = result;
-  }
-
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
@@ -245,7 +240,12 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
     std::string userhash;
     DBusThreadManager::Get()->GetCryptohomeClient()->GetSanitizedUsername(
         cryptohome::Identification(user->GetAccountId()),
-        base::Bind(&AssignString, &userhash_));
+        base::BindOnce(
+            [](std::string* out, base::Optional<std::string> result) {
+              CHECK(result.has_value());
+              *out = std::move(result).value();
+            },
+            &userhash_));
     content::RunAllPendingInMessageLoop();
     CHECK(!userhash_.empty());
   }
@@ -494,14 +494,12 @@ class NetworkingPrivateChromeOSApiTest : public ExtensionApiTest {
   }
 
   bool SetupCertificates() {
-    scoped_refptr<net::X509Certificate> system_ca_cert =
-        net::ImportCertFromFile(net::GetTestCertsDirectory(),
-                                "client_1_ca.pem");
-    if (!system_ca_cert)
+    net::ScopedCERTCertificateList cert_list =
+        net::CreateCERTCertificateListFromFile(
+            net::GetTestCertsDirectory(), "client_1_ca.pem",
+            net::X509Certificate::FORMAT_AUTO);
+    if (cert_list.empty())
       return false;
-
-    net::CertificateList cert_list;
-    cert_list.push_back(std::move(system_ca_cert));
     // TODO(stevenjb): Figure out a simple way to import a test user cert.
 
     chromeos::NetworkHandler::Get()
@@ -609,6 +607,12 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, RequestNetworkScan) {
   EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScan")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       RequestNetworkScanCellular) {
+  SetupCellular();
+  EXPECT_TRUE(RunNetworkingSubtest("requestNetworkScanCellular")) << message_;
+}
+
 // Properties are filtered and translated through
 // ShillToONCTranslator::TranslateWiFiWithState
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetProperties) {
@@ -621,6 +625,27 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
   EXPECT_TRUE(RunNetworkingSubtest("getPropertiesCellular")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       GetCellularPropertiesDefault) {
+  SetupCellular();
+  const chromeos::NetworkState* cellular =
+      chromeos::NetworkHandler::Get()
+          ->network_state_handler()
+          ->FirstNetworkByType(chromeos::NetworkTypePattern::Cellular());
+  ASSERT_TRUE(cellular);
+  std::string cellular_guid = std::string(kCellular1ServicePath) + "_guid";
+  EXPECT_EQ(cellular_guid, cellular->guid());
+  // Remove the Cellular service. This should create a default Cellular network.
+  service_test_->RemoveService(kCellular1ServicePath);
+  content::RunAllPendingInMessageLoop();
+  cellular = chromeos::NetworkHandler::Get()
+                 ->network_state_handler()
+                 ->FirstNetworkByType(chromeos::NetworkTypePattern::Cellular());
+  ASSERT_TRUE(cellular);
+  EXPECT_EQ(cellular_guid, cellular->guid());
+  EXPECT_TRUE(RunNetworkingSubtest("getPropertiesCellularDefault")) << message_;
+}
+
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetState) {
   EXPECT_TRUE(RunNetworkingSubtest("getState")) << message_;
 }
@@ -870,6 +895,28 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, SetCellularSimState) {
   EXPECT_TRUE(RunNetworkingSubtest("setCellularSimState")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       SelectCellularMobileNetwork) {
+  SetupCellular();
+  // Create fake list of found networks.
+  std::unique_ptr<base::ListValue> found_networks =
+      extensions::ListBuilder()
+          .Append(extensions::DictionaryBuilder()
+                      .Set(shill::kNetworkIdProperty, "network1")
+                      .Set(shill::kTechnologyProperty, "GSM")
+                      .Set(shill::kStatusProperty, "current")
+                      .Build())
+          .Append(extensions::DictionaryBuilder()
+                      .Set(shill::kNetworkIdProperty, "network2")
+                      .Set(shill::kTechnologyProperty, "GSM")
+                      .Set(shill::kStatusProperty, "available")
+                      .Build())
+          .Build();
+  device_test_->SetDeviceProperty(
+      kCellularDevicePath, shill::kFoundNetworksProperty, *found_networks);
+  EXPECT_TRUE(RunNetworkingSubtest("selectCellularMobileNetwork")) << message_;
+}
+
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, CellularSimPuk) {
   SetupCellular();
   // Lock the SIM
diff --git a/chromium/chrome/browser/extensions/api/notifications/extension_notification_display_helper.cc b/chromium/chrome/browser/extensions/api/notifications/extension_notification_display_helper.cc
index cfbdfc490ee..3aefc700154 100644
--- a/chromium/chrome/browser/extensions/api/notifications/extension_notification_display_helper.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/extension_notification_display_helper.cc
@@ -25,18 +25,18 @@ void ExtensionNotificationDisplayHelper::Display(
     const Notification& notification) {
   // Remove the previous version of this notification if the |notification| is
   // updating another notification.
-  EraseDataForNotificationId(notification.delegate_id());
+  EraseDataForNotificationId(notification.id());
 
   notifications_.push_back(base::MakeUnique<Notification>(notification));
 
-  GetDisplayService()->Display(NotificationCommon::EXTENSION,
-                               notification.delegate_id(), notification);
+  GetDisplayService()->Display(NotificationCommon::EXTENSION, notification.id(),
+                               notification);
 }
 
 Notification* ExtensionNotificationDisplayHelper::GetByNotificationId(
     const std::string& notification_id) {
   for (const auto& notification : notifications_) {
-    if (notification->delegate_id() == notification_id)
+    if (notification->id() == notification_id)
       return notification.get();
   }
 
@@ -49,7 +49,7 @@ ExtensionNotificationDisplayHelper::GetNotificationIdsForExtension(
   std::set<std::string> notification_ids;
   for (const auto& notification : notifications_) {
     if (notification->origin_url() == extension_origin)
-      notification_ids.insert(notification->delegate_id());
+      notification_ids.insert(notification->id());
   }
 
   return notification_ids;
@@ -60,7 +60,7 @@ bool ExtensionNotificationDisplayHelper::EraseDataForNotificationId(
   auto iter = std::find_if(
       notifications_.begin(), notifications_.end(),
       [notification_id](const std::unique_ptr<Notification>& notification) {
-        return notification->delegate_id() == notification_id;
+        return notification->id() == notification_id;
       });
 
   if (iter == notifications_.end())
diff --git a/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.cc b/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.cc
index 645a1f5ac4e..987c9324ec4 100644
--- a/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.cc
@@ -86,21 +86,21 @@ void ExtensionNotificationHandler::OnClick(
     Profile* profile,
     const std::string& origin,
     const std::string& notification_id,
-    int action_index,
-    const base::NullableString16& reply) {
-  DCHECK(reply.is_null());
+    const base::Optional<int>& action_index,
+    const base::Optional<base::string16>& reply) {
+  DCHECK(!reply.has_value());
 
   std::string extension_id(GetExtensionId(origin));
   std::unique_ptr<base::ListValue> args(
       CreateBaseEventArgs(extension_id, notification_id));
-  if (action_index > -1)
-    args->AppendInteger(action_index);
+  if (action_index.has_value())
+    args->AppendInteger(action_index.value());
   events::HistogramValue histogram_value =
-      action_index > -1 ? events::NOTIFICATIONS_ON_BUTTON_CLICKED
-                        : events::NOTIFICATIONS_ON_CLICKED;
+      action_index.has_value() ? events::NOTIFICATIONS_ON_BUTTON_CLICKED
+                               : events::NOTIFICATIONS_ON_CLICKED;
   const std::string& event_name =
-      action_index > -1 ? api::notifications::OnButtonClicked::kEventName
-                        : api::notifications::OnClicked::kEventName;
+      action_index.has_value() ? api::notifications::OnButtonClicked::kEventName
+                               : api::notifications::OnClicked::kEventName;
 
   SendEvent(profile, extension_id, histogram_value, event_name,
             EventRouter::USER_GESTURE_ENABLED, std::move(args));
diff --git a/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.h b/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.h
index 9019ca3eddd..cbdc66770b9 100644
--- a/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.h
+++ b/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler.h
@@ -34,8 +34,8 @@ class ExtensionNotificationHandler : public NotificationHandler {
   void OnClick(Profile* profile,
                const std::string& origin,
                const std::string& notification_id,
-               int action_index,
-               const base::NullableString16& reply) override;
+               const base::Optional<int>& action_index,
+               const base::Optional<base::string16>& reply) override;
   void OpenSettings(Profile* profile) override;
   bool ShouldDisplayOnFullScreen(Profile* profile,
                                  const std::string& origin) override;
diff --git a/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler_unittest.cc b/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler_unittest.cc
index 239e8681b72..1c4608171ac 100644
--- a/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/extension_notification_handler_unittest.cc
@@ -4,7 +4,7 @@
 
 #include <string>
 
-#include "base/strings/nullable_string16.h"
+#include "base/optional.h"
 #include "chrome/browser/extensions/api/notifications/extension_notification_handler.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/test/base/testing_browser_process.h"
@@ -69,7 +69,7 @@ TEST_F(ExtensionNotificationHandlerTest, CloseHandler) {
   TestExtensionNotificationHandler handler;
   handler.SetTestExpectations(kChromeExtensionId, "notifications.onClosed", 2);
   handler.OnClose(profile.get(), kChromeExtensionOrigin, kChromeNotificationId,
-                  false);
+                  false /* by_user */);
 }
 
 TEST_F(ExtensionNotificationHandlerTest, ClickHandler) {
@@ -80,7 +80,7 @@ TEST_F(ExtensionNotificationHandlerTest, ClickHandler) {
   TestExtensionNotificationHandler handler;
   handler.SetTestExpectations(kChromeExtensionId, "notifications.onClicked", 1);
   handler.OnClick(profile.get(), kChromeExtensionOrigin, kChromeNotificationId,
-                  -1, base::NullableString16() /* reply */);
+                  base::nullopt /* action_index */, base::nullopt /* reply */);
 }
 
 TEST_F(ExtensionNotificationHandlerTest, ClickHandlerButton) {
@@ -92,7 +92,7 @@ TEST_F(ExtensionNotificationHandlerTest, ClickHandlerButton) {
   handler.SetTestExpectations(kChromeExtensionId,
                               "notifications.onButtonClicked", 2);
   handler.OnClick(profile.get(), kChromeExtensionOrigin, kChromeNotificationId,
-                  1, base::NullableString16() /* reply */);
+                  1 /* action_index */, base::nullopt /* reply */);
 }
 
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc b/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc
index 4e3a9bf8ed8..1da3660ae5d 100644
--- a/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/notifications_api.cc
@@ -16,6 +16,7 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ -24,7 +25,6 @@
 #include "chrome/browser/extensions/api/notifications/extension_notification_display_helper_factory.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_common.h"
-#include "chrome/browser/notifications/notification_delegate.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"
@@ -49,8 +49,9 @@
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/skia_util.h"
-#include "ui/message_center/message_center_style.h"
+#include "ui/message_center/notification_delegate.h"
 #include "ui/message_center/notifier_settings.h"
+#include "ui/message_center/public/cpp/message_center_constants.h"
 #include "url/gurl.h"
 
 using message_center::NotifierId;
@@ -61,6 +62,10 @@ namespace notifications = api::notifications;
 
 namespace {
 
+// The maximum length of a notification ID, in number of characters. Some
+// platforms have limitattions on the length of the ID.
+constexpr int kNotificationIdLengthLimit = 500;
+
 const char kMissingRequiredPropertiesForCreateNotification[] =
     "Some of the required properties are missing: type, iconUrl, title and "
     "message.";
@@ -74,6 +79,8 @@ const char kExtraListItemsProvided[] =
     "List items provided for notification type != list";
 const char kExtraImageProvided[] =
     "Image resource provided for notification type != image";
+const char kNotificationIdTooLong[] =
+    "The notification's ID should be %d characters or less";
 
 #if !defined(OS_CHROMEOS)
 const char kLowPriorityDeprecatedOnPlatform[] =
@@ -160,7 +167,7 @@ bool NotificationBitmapToGfxImage(
     return false;
 
   // Ensure that our bitmap and our data now refer to the same number of pixels.
-  if (rgba_data_length != bitmap.getSafeSize())
+  if (rgba_data_length != bitmap.computeByteSize())
     return false;
 
   uint32_t* pixels = bitmap.getAddr32(0, 0);
@@ -336,17 +343,23 @@ bool NotificationsApiFunction::CreateNotification(
   if (options->is_clickable.get())
     optional_fields.clickable = *options->is_clickable;
 
-  // Create the notification api delegate. Ownership passed to the notification.
-  NotificationDelegate* api_delegate = new WebNotificationDelegate(
-      NotificationCommon::EXTENSION, GetProfile(),
-      CreateScopedIdentifier(extension_->id(), id), extension_->url());
+  // TODO(crbug.com/772004): Remove the manual limitation in favor of an IDL
+  // annotation once supported.
+  if (id.size() > kNotificationIdLengthLimit) {
+    SetError(
+        base::StringPrintf(kNotificationIdTooLong, kNotificationIdLengthLimit));
+    return false;
+  }
 
+  std::string notification_id = CreateScopedIdentifier(extension_->id(), id);
   Notification notification(
-      type, title, message, icon,
+      type, notification_id, title, message, icon,
       message_center::NotifierId(message_center::NotifierId::APPLICATION,
                                  extension_->id()),
-      base::UTF8ToUTF16(extension_->name()), extension_->url(),
-      api_delegate->id(), optional_fields, api_delegate);
+      base::UTF8ToUTF16(extension_->name()), extension_->url(), notification_id,
+      optional_fields,
+      new WebNotificationDelegate(NotificationCommon::EXTENSION, GetProfile(),
+                                  notification_id, extension_->url()));
 
   // Apply the "requireInteraction" flag. The value defaults to false.
   notification.set_never_timeout(options->require_interaction &&
diff --git a/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc b/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc
index fef2b34cbc3..49cc0e431c4 100644
--- a/chromium/chrome/browser/extensions/api/notifications/notifications_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/notifications/notifications_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 "base/containers/circular_deque.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ -98,7 +99,7 @@ class UserGestureCatcher : public content::NotificationObserver {
   content::NotificationRegistrar registrar_;
 
   // A sequential list of user gesture notifications from the test extension(s).
-  std::deque<bool> results_;
+  base::circular_deque<bool> results_;
 
   // True if we're in a nested run loop waiting for results from
   // the extension.
@@ -298,8 +299,6 @@ IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestPartialUpdate) {
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
-  LOG(INFO) << "Notification ID: " << notification->id();
-
   EXPECT_EQ(base::ASCIIToUTF16(kNewTitle), notification->title());
   EXPECT_EQ(base::ASCIIToUTF16(kNewMessage), notification->message());
   EXPECT_EQ(kNewPriority, notification->priority());
@@ -323,7 +322,7 @@ IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestGetPermissionLevel) {
     std::unique_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
         notification_function.get(), "[]", browser(), utils::NONE));
 
-    EXPECT_EQ(base::Value::Type::STRING, result->GetType());
+    EXPECT_EQ(base::Value::Type::STRING, result->type());
     std::string permission_level;
     EXPECT_TRUE(result->GetAsString(&permission_level));
     EXPECT_EQ("granted", permission_level);
@@ -346,7 +345,7 @@ IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestGetPermissionLevel) {
     std::unique_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
         notification_function.get(), "[]", browser(), utils::NONE));
 
-    EXPECT_EQ(base::Value::Type::STRING, result->GetType());
+    EXPECT_EQ(base::Value::Type::STRING, result->type());
     std::string permission_level;
     EXPECT_TRUE(result->GetAsString(&permission_level));
     EXPECT_EQ("denied", permission_level);
diff --git a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.cc b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.cc
index 6fcfcfddccd..86fe43dbd3b 100644
--- a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.cc
+++ b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.cc
@@ -77,7 +77,7 @@ bool SetOmniboxDefaultSuggestion(
   // omnibox::SuggestResult.
   dict->SetWithoutPathExpansion(
       kSuggestionContent,
-      base::MakeUnique<base::Value>(base::Value::Type::STRING));
+      std::make_unique<base::Value>(base::Value::Type::STRING));
   prefs->UpdateExtensionPref(extension_id, kOmniboxDefaultSuggestion,
                              std::move(dict));
 
@@ -96,9 +96,9 @@ std::string GetTemplateURLStringForExtension(const std::string& extension_id) {
 // static
 void ExtensionOmniboxEventRouter::OnInputStarted(
     Profile* profile, const std::string& extension_id) {
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::OMNIBOX_ON_INPUT_STARTED, omnibox::OnInputStarted::kEventName,
-      base::MakeUnique<base::ListValue>(), profile);
+      std::make_unique<base::ListValue>(), profile);
   EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, std::move(event));
 }
@@ -112,11 +112,11 @@ bool ExtensionOmniboxEventRouter::OnInputChanged(
           extension_id, omnibox::OnInputChanged::kEventName))
     return false;
 
-  std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Set(0, base::MakeUnique<base::Value>(input));
-  args->Set(1, base::MakeUnique<base::Value>(suggest_id));
+  auto args(std::make_unique<base::ListValue>());
+  args->Set(0, std::make_unique<base::Value>(input));
+  args->Set(1, std::make_unique<base::Value>(suggest_id));
 
-  auto event = base::MakeUnique<Event>(events::OMNIBOX_ON_INPUT_CHANGED,
+  auto event = std::make_unique<Event>(events::OMNIBOX_ON_INPUT_CHANGED,
                                        omnibox::OnInputChanged::kEventName,
                                        std::move(args), profile);
   event_router->DispatchEventToExtension(extension_id, std::move(event));
@@ -139,16 +139,16 @@ void ExtensionOmniboxEventRouter::OnInputEntered(
   extensions::TabHelper::FromWebContents(web_contents)->
       active_tab_permission_granter()->GrantIfRequested(extension);
 
-  std::unique_ptr<base::ListValue> args(new base::ListValue());
-  args->Set(0, base::MakeUnique<base::Value>(input));
+  auto args(std::make_unique<base::ListValue>());
+  args->Set(0, std::make_unique<base::Value>(input));
   if (disposition == WindowOpenDisposition::NEW_FOREGROUND_TAB)
-    args->Set(1, base::MakeUnique<base::Value>(kForegroundTabDisposition));
+    args->Set(1, std::make_unique<base::Value>(kForegroundTabDisposition));
   else if (disposition == WindowOpenDisposition::NEW_BACKGROUND_TAB)
-    args->Set(1, base::MakeUnique<base::Value>(kBackgroundTabDisposition));
+    args->Set(1, std::make_unique<base::Value>(kBackgroundTabDisposition));
   else
-    args->Set(1, base::MakeUnique<base::Value>(kCurrentTabDisposition));
+    args->Set(1, std::make_unique<base::Value>(kCurrentTabDisposition));
 
-  auto event = base::MakeUnique<Event>(events::OMNIBOX_ON_INPUT_ENTERED,
+  auto event = std::make_unique<Event>(events::OMNIBOX_ON_INPUT_ENTERED,
                                        omnibox::OnInputEntered::kEventName,
                                        std::move(args), profile);
   EventRouter::Get(profile)
@@ -163,13 +163,28 @@ void ExtensionOmniboxEventRouter::OnInputEntered(
 // static
 void ExtensionOmniboxEventRouter::OnInputCancelled(
     Profile* profile, const std::string& extension_id) {
-  auto event = base::MakeUnique<Event>(
+  auto event = std::make_unique<Event>(
       events::OMNIBOX_ON_INPUT_CANCELLED, omnibox::OnInputCancelled::kEventName,
-      base::MakeUnique<base::ListValue>(), profile);
+      std::make_unique<base::ListValue>(), profile);
   EventRouter::Get(profile)
       ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
+void ExtensionOmniboxEventRouter::OnDeleteSuggestion(
+    Profile* profile,
+    const std::string& extension_id,
+    const std::string& suggestion_text) {
+  auto args(std::make_unique<base::ListValue>());
+  args->Set(0, std::make_unique<base::Value>(suggestion_text));
+
+  auto event = std::make_unique<Event>(events::OMNIBOX_ON_DELETE_SUGGESTION,
+                                       omnibox::OnDeleteSuggestion::kEventName,
+                                       std::move(args), profile);
+
+  EventRouter::Get(profile)->DispatchEventToExtension(extension_id,
+                                                      std::move(event));
+}
+
 OmniboxAPI::OmniboxAPI(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)),
       url_service_(TemplateURLServiceFactory::GetForProfile(profile_)),
@@ -192,13 +207,12 @@ void OmniboxAPI::Shutdown() {
 OmniboxAPI::~OmniboxAPI() {
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<OmniboxAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<OmniboxAPI>>::
+    DestructorAtExit g_omnibox_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<OmniboxAPI>* OmniboxAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_omnibox_api_factory.Pointer();
 }
 
 // static
diff --git a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.h b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.h
index 2548083ad1d..27c7981cfc1 100644
--- a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.h
+++ b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api.h
@@ -65,6 +65,11 @@ class ExtensionOmniboxEventRouter {
   static void OnInputCancelled(
       Profile* profile, const std::string& extension_id);
 
+  // The user has deleted an extension omnibox suggestion result.
+  static void OnDeleteSuggestion(Profile* profile,
+                                 const std::string& extension_id,
+                                 const std::string& suggestion_text);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionOmniboxEventRouter);
 };
diff --git a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc
index c904a0ba743..a4f2d232d4d 100644
--- a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc
@@ -40,10 +40,10 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_Basic) {
   // Test that our extension's keyword is suggested to us when we partially type
   // it.
   {
-    autocomplete_controller->Start(AutocompleteInput(
-        ASCIIToUTF16("keywor"), base::string16::npos, std::string(), GURL(),
-        base::string16(), OmniboxEventProto::NTP, true, false, true, true,
-        false, ChromeAutocompleteSchemeClassifier(profile)));
+    AutocompleteInput input(ASCIIToUTF16("keywor"),
+                            metrics::OmniboxEventProto::NTP,
+                            ChromeAutocompleteSchemeClassifier(profile));
+    autocomplete_controller->Start(input);
     WaitForAutocompleteDone(autocomplete_controller);
     EXPECT_TRUE(autocomplete_controller->done());
 
@@ -57,15 +57,15 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_Basic) {
     EXPECT_FALSE(match.deletable);
 
     match = result.match_at(1);
-    EXPECT_EQ(ASCIIToUTF16("keyword"), match.keyword);
+    EXPECT_EQ(ASCIIToUTF16("kw"), match.keyword);
   }
 
   // Test that our extension can send suggestions back to us.
   {
-    autocomplete_controller->Start(AutocompleteInput(
-        ASCIIToUTF16("keyword suggestio"), base::string16::npos, std::string(),
-        GURL(), base::string16(), OmniboxEventProto::NTP, true, false, true,
-        true, false, ChromeAutocompleteSchemeClassifier(profile)));
+    AutocompleteInput input(ASCIIToUTF16("kw suggestio"),
+                            metrics::OmniboxEventProto::NTP,
+                            ChromeAutocompleteSchemeClassifier(profile));
+    autocomplete_controller->Start(input);
     WaitForAutocompleteDone(autocomplete_controller);
     EXPECT_TRUE(autocomplete_controller->done());
 
@@ -76,25 +76,24 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_Basic) {
     const AutocompleteResult& result = autocomplete_controller->result();
     ASSERT_EQ(5U, result.size()) << AutocompleteResultAsString(result);
 
-    EXPECT_EQ(ASCIIToUTF16("keyword"), result.match_at(0).keyword);
-    EXPECT_EQ(ASCIIToUTF16("keyword suggestio"),
-              result.match_at(0).fill_into_edit);
+    EXPECT_EQ(ASCIIToUTF16("kw"), result.match_at(0).keyword);
+    EXPECT_EQ(ASCIIToUTF16("kw suggestio"), result.match_at(0).fill_into_edit);
     EXPECT_EQ(AutocompleteMatchType::SEARCH_OTHER_ENGINE,
               result.match_at(0).type);
     EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
               result.match_at(0).provider->type());
-    EXPECT_EQ(ASCIIToUTF16("keyword"), result.match_at(1).keyword);
-    EXPECT_EQ(ASCIIToUTF16("keyword suggestion1"),
+    EXPECT_EQ(ASCIIToUTF16("kw"), result.match_at(1).keyword);
+    EXPECT_EQ(ASCIIToUTF16("kw suggestion1"),
               result.match_at(1).fill_into_edit);
     EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
               result.match_at(1).provider->type());
-    EXPECT_EQ(ASCIIToUTF16("keyword"), result.match_at(2).keyword);
-    EXPECT_EQ(ASCIIToUTF16("keyword suggestion2"),
+    EXPECT_EQ(ASCIIToUTF16("kw"), result.match_at(2).keyword);
+    EXPECT_EQ(ASCIIToUTF16("kw suggestion2"),
               result.match_at(2).fill_into_edit);
     EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
               result.match_at(2).provider->type());
-    EXPECT_EQ(ASCIIToUTF16("keyword"), result.match_at(3).keyword);
-    EXPECT_EQ(ASCIIToUTF16("keyword suggestion3"),
+    EXPECT_EQ(ASCIIToUTF16("kw"), result.match_at(3).keyword);
+    EXPECT_EQ(ASCIIToUTF16("kw suggestion3"),
               result.match_at(3).fill_into_edit);
     EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
               result.match_at(3).provider->type());
@@ -148,7 +147,7 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_Basic) {
     ResultCatcher catcher;
     OmniboxView* omnibox_view = location_bar->GetOmniboxView();
     omnibox_view->OnBeforePossibleChange();
-    omnibox_view->SetUserText(ASCIIToUTF16("keyword command"));
+    omnibox_view->SetUserText(ASCIIToUTF16("kw command"));
     omnibox_view->OnAfterPossibleChange(true);
     location_bar->AcceptInput();
     // This checks that the keyword provider (via javascript)
@@ -170,28 +169,32 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, OnInputEntered) {
   AutocompleteController* autocomplete_controller =
       GetAutocompleteController(browser());
   omnibox_view->OnBeforePossibleChange();
-  omnibox_view->SetUserText(ASCIIToUTF16("keyword command"));
+  omnibox_view->SetUserText(ASCIIToUTF16("kw command"));
   omnibox_view->OnAfterPossibleChange(true);
 
-  autocomplete_controller->Start(AutocompleteInput(
-      ASCIIToUTF16("keyword command"), base::string16::npos, std::string(),
-      GURL(), base::string16(), OmniboxEventProto::NTP, true, false, true, true,
-      false, ChromeAutocompleteSchemeClassifier(profile)));
+  {
+    AutocompleteInput input(ASCIIToUTF16("kw command"),
+                            metrics::OmniboxEventProto::NTP,
+                            ChromeAutocompleteSchemeClassifier(profile));
+    autocomplete_controller->Start(input);
+  }
   omnibox_view->model()->AcceptInput(WindowOpenDisposition::CURRENT_TAB, false);
   WaitForAutocompleteDone(autocomplete_controller);
   EXPECT_TRUE(autocomplete_controller->done());
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   omnibox_view->OnBeforePossibleChange();
-  omnibox_view->SetUserText(ASCIIToUTF16("keyword newtab"));
+  omnibox_view->SetUserText(ASCIIToUTF16("kw newtab"));
   omnibox_view->OnAfterPossibleChange(true);
   WaitForAutocompleteDone(autocomplete_controller);
   EXPECT_TRUE(autocomplete_controller->done());
 
-  autocomplete_controller->Start(AutocompleteInput(
-      ASCIIToUTF16("keyword newtab"), base::string16::npos, std::string(),
-      GURL(), base::string16(), OmniboxEventProto::NTP, true, false, true, true,
-      false, ChromeAutocompleteSchemeClassifier(profile)));
+  {
+    AutocompleteInput input(ASCIIToUTF16("kw newtab"),
+                            metrics::OmniboxEventProto::NTP,
+                            ChromeAutocompleteSchemeClassifier(profile));
+    autocomplete_controller->Start(input);
+  }
   omnibox_view->model()->AcceptInput(WindowOpenDisposition::NEW_FOREGROUND_TAB,
                                      false);
   WaitForAutocompleteDone(autocomplete_controller);
@@ -226,10 +229,10 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_IncognitoSplitMode) {
 
   // Test that we get the incognito-specific suggestions.
   {
-    autocomplete_controller->Start(AutocompleteInput(
-        ASCIIToUTF16("keyword suggestio"), base::string16::npos, std::string(),
-        GURL(), base::string16(), OmniboxEventProto::NTP, true, false, true,
-        true, false, ChromeAutocompleteSchemeClassifier(profile)));
+    AutocompleteInput input(ASCIIToUTF16("kw suggestio"),
+                            metrics::OmniboxEventProto::NTP,
+                            ChromeAutocompleteSchemeClassifier(profile));
+    autocomplete_controller->Start(input);
     WaitForAutocompleteDone(autocomplete_controller);
     EXPECT_TRUE(autocomplete_controller->done());
 
@@ -239,7 +242,7 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_IncognitoSplitMode) {
     const AutocompleteResult& result = autocomplete_controller->result();
     ASSERT_EQ(5U, result.size()) << AutocompleteResultAsString(result);
     ASSERT_FALSE(result.match_at(0).keyword.empty());
-    EXPECT_EQ(ASCIIToUTF16("keyword suggestion3 incognito"),
+    EXPECT_EQ(ASCIIToUTF16("kw suggestion3 incognito"),
               result.match_at(3).fill_into_edit);
   }
 
@@ -248,10 +251,10 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DISABLED_IncognitoSplitMode) {
   // incognito context.
   {
     ResultCatcher catcher;
-    autocomplete_controller->Start(AutocompleteInput(
-        ASCIIToUTF16("keyword command incognito"), base::string16::npos,
-        std::string(), GURL(), base::string16(), OmniboxEventProto::NTP, true,
-        false, true, true, false, ChromeAutocompleteSchemeClassifier(profile)));
+    AutocompleteInput input(ASCIIToUTF16("kw command incognito"),
+                            metrics::OmniboxEventProto::NTP,
+                            ChromeAutocompleteSchemeClassifier(profile));
+    autocomplete_controller->Start(input);
     location_bar->AcceptInput();
     EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   }
diff --git a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc
index 5a9736e5943..777cc5d0b37 100644
--- a/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc
+++ b/chromium/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc
@@ -2,13 +2,31 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api_testbase.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
+#include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/view_ids.h"
+#include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/base/search_test_utils.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
+#include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 
+namespace {
+
+void InputKeys(Browser* browser, const std::vector<ui::KeyboardCode>& keys) {
+  for (auto key : keys) {
+    // Note that sending key presses can be flaky at times.
+    ASSERT_TRUE(ui_test_utils::SendKeyPressSync(browser, key, false, false,
+                                                false, false));
+  }
+}
+
+}  // namespace
+
 // Tests that the autocomplete popup doesn't reopen after accepting input for
 // a given query.
 // http://crbug.com/88552
@@ -29,7 +47,7 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, PopupStaysClosed) {
 
   // Input a keyword query and wait for suggestions from the extension.
   omnibox_view->OnBeforePossibleChange();
-  omnibox_view->SetUserText(base::ASCIIToUTF16("keyword comman"));
+  omnibox_view->SetUserText(base::ASCIIToUTF16("kw comman"));
   omnibox_view->OnAfterPossibleChange(true);
   WaitForAutocompleteDone(autocomplete_controller);
   EXPECT_TRUE(autocomplete_controller->done());
@@ -43,11 +61,10 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, PopupStaysClosed) {
   // TODO: Rather than send this second request by talking to the controller
   // directly, figure out how to send it via the proper calls to
   // location_bar or location_bar->().
-  autocomplete_controller->Start(AutocompleteInput(
-      base::ASCIIToUTF16("keyword command"), base::string16::npos,
-      std::string(), GURL(), base::string16(), metrics::OmniboxEventProto::NTP,
-      true, false, true, true, false,
-      ChromeAutocompleteSchemeClassifier(profile)));
+  AutocompleteInput input(base::ASCIIToUTF16("kw command"),
+                          metrics::OmniboxEventProto::NTP,
+                          ChromeAutocompleteSchemeClassifier(profile));
+  autocomplete_controller->Start(input);
   location_bar->AcceptInput();
   WaitForAutocompleteDone(autocomplete_controller);
   EXPECT_TRUE(autocomplete_controller->done());
@@ -56,3 +73,76 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, PopupStaysClosed) {
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   EXPECT_FALSE(popup_model->IsOpen());
 }
+
+// Tests deleting a deletable omnibox extension suggestion result.
+IN_PROC_BROWSER_TEST_F(OmniboxApiTest, DeleteOmniboxSuggestionResult) {
+  ASSERT_TRUE(RunExtensionTest("omnibox")) << message_;
+
+  // The results depend on the TemplateURLService being loaded. Make sure it is
+  // loaded so that the autocomplete results are consistent.
+  Profile* profile = browser()->profile();
+  search_test_utils::WaitForTemplateURLServiceToLoad(
+      TemplateURLServiceFactory::GetForProfile(profile));
+
+  AutocompleteController* autocomplete_controller =
+      GetAutocompleteController(browser());
+
+  chrome::FocusLocationBar(browser());
+  ASSERT_TRUE(ui_test_utils::IsViewFocused(browser(), VIEW_ID_OMNIBOX));
+
+  // Input a keyword query and wait for suggestions from the extension.
+  InputKeys(browser(), {ui::VKEY_K, ui::VKEY_W, ui::VKEY_SPACE, ui::VKEY_D});
+
+  WaitForAutocompleteDone(autocomplete_controller);
+  EXPECT_TRUE(autocomplete_controller->done());
+
+  // Peek into the controller to see if it has the results we expect.
+  const AutocompleteResult& result = autocomplete_controller->result();
+  ASSERT_EQ(4U, result.size()) << AutocompleteResultAsString(result);
+
+  EXPECT_EQ(base::ASCIIToUTF16("kw d"), result.match_at(0).fill_into_edit);
+  EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
+            result.match_at(0).provider->type());
+  EXPECT_FALSE(result.match_at(0).deletable);
+
+  EXPECT_EQ(base::ASCIIToUTF16("kw n1"), result.match_at(1).fill_into_edit);
+  EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
+            result.match_at(1).provider->type());
+  // Verify that the first omnibox extension suggestion is deletable.
+  EXPECT_TRUE(result.match_at(1).deletable);
+
+  EXPECT_EQ(base::ASCIIToUTF16("kw n2"), result.match_at(2).fill_into_edit);
+  EXPECT_EQ(AutocompleteProvider::TYPE_KEYWORD,
+            result.match_at(2).provider->type());
+  // Verify that the second omnibox extension suggestion is not deletable.
+  EXPECT_FALSE(result.match_at(2).deletable);
+
+  EXPECT_EQ(base::ASCIIToUTF16("kw d"), result.match_at(3).fill_into_edit);
+  EXPECT_EQ(AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+            result.match_at(3).type);
+  EXPECT_FALSE(result.match_at(3).deletable);
+
+// This test portion is excluded from Mac because the Mac key combination
+// FN+SHIFT+DEL used to delete an omnibox suggestion cannot be reproduced.
+// This is because the FN key is not supported in interactive_test_util.h.
+#if !defined(OS_MACOSX)
+  ExtensionTestMessageListener delete_suggestion_listener(
+      "onDeleteSuggestion: des1", false);
+
+  // Skip the first suggestion result.
+  EXPECT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_DOWN, false,
+                                              false, false, false));
+  // Delete the second suggestion result. On Linux, this is done via SHIFT+DEL.
+  EXPECT_TRUE(ui_test_utils::SendKeyPressSync(browser(), ui::VKEY_DELETE, false,
+                                              true, false, false));
+  // Verify that the onDeleteSuggestion event was fired.
+  ASSERT_TRUE(delete_suggestion_listener.WaitUntilSatisfied());
+
+  // Verify that the first suggestion result was deleted. There should be one
+  // less suggestion result, 3 now instead of 4.
+  ASSERT_EQ(3U, result.size());
+  EXPECT_EQ(base::ASCIIToUTF16("kw d"), result.match_at(0).fill_into_edit);
+  EXPECT_EQ(base::ASCIIToUTF16("kw n2"), result.match_at(1).fill_into_edit);
+  EXPECT_EQ(base::ASCIIToUTF16("kw d"), result.match_at(2).fill_into_edit);
+#endif
+}
diff --git a/chromium/chrome/browser/extensions/api/page_capture/page_capture_apitest.cc b/chromium/chrome/browser/extensions/api/page_capture/page_capture_apitest.cc
index 10671beb8e2..6bc8dc15753 100644
--- a/chromium/chrome/browser/extensions/api/page_capture/page_capture_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/page_capture/page_capture_apitest.cc
@@ -58,7 +58,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionPageCaptureApiTest, SaveAsMHTML) {
   // Make sure the MHTML data gets written to the temporary file.
   ASSERT_FALSE(delegate.temp_file_.empty());
   // Flush the message loops to make sure the delete happens.
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   content::RunAllPendingInMessageLoop(content::BrowserThread::IO);
   // Make sure the temporary file is destroyed once the javascript side reads
   // the contents.
@@ -76,7 +76,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionPageCaptureApiTest,
   ScopedTestDialogAutoConfirm auto_confirm(ScopedTestDialogAutoConfirm::ACCEPT);
   ASSERT_TRUE(RunExtensionTest("page_capture")) << message_;
   ASSERT_FALSE(delegate.temp_file_.empty());
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
   content::RunAllPendingInMessageLoop(content::BrowserThread::IO);
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   ASSERT_FALSE(base::PathExists(delegate.temp_file_));
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.cc b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.cc
index 22d1c6979a8..eebc8e3692e 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.cc
@@ -4,6 +4,8 @@
 
 #include "chrome/browser/extensions/api/passwords_private/passwords_private_api.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
@@ -33,8 +35,8 @@ ExtensionFunction::ResponseAction
   PasswordsPrivateDelegate* delegate =
       PasswordsPrivateDelegateFactory::GetForBrowserContext(browser_context(),
                                                             true /* create */);
-  delegate->RemoveSavedPassword(parameters->login_pair.urls.origin,
-                                parameters->login_pair.username);
+
+  delegate->RemoveSavedPassword(parameters->index);
 
   return RespondNow(NoArguments());
 }
@@ -56,7 +58,23 @@ ExtensionFunction::ResponseAction
   PasswordsPrivateDelegate* delegate =
       PasswordsPrivateDelegateFactory::GetForBrowserContext(browser_context(),
                                                             true /* create */);
-  delegate->RemovePasswordException(parameters->exception_url);
+  delegate->RemovePasswordException(parameters->index);
+
+  return RespondNow(NoArguments());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction
+
+PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction::
+    ~PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction() {}
+
+ExtensionFunction::ResponseAction
+PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction::Run() {
+  PasswordsPrivateDelegate* delegate =
+      PasswordsPrivateDelegateFactory::GetForBrowserContext(browser_context(),
+                                                            true /* create */);
+  delegate->UndoRemoveSavedPasswordOrException();
 
   return RespondNow(NoArguments());
 }
@@ -78,10 +96,7 @@ ExtensionFunction::ResponseAction
   PasswordsPrivateDelegate* delegate =
       PasswordsPrivateDelegateFactory::GetForBrowserContext(browser_context(),
                                                             true /* create */);
-
-  delegate->RequestShowPassword(parameters->login_pair.urls.origin,
-                                parameters->login_pair.username,
-                                GetSenderWebContents());
+  delegate->RequestShowPassword(parameters->index, GetSenderWebContents());
 
   // No response given from this API function; instead, listeners wait for the
   // chrome.passwordsPrivate.onPlaintextPasswordRetrieved event to fire.
@@ -151,4 +166,34 @@ void PasswordsPrivateGetPasswordExceptionListFunction::GotList(
           entries)));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// PasswordsPrivateImportPasswordsFunction
+
+PasswordsPrivateImportPasswordsFunction::
+    ~PasswordsPrivateImportPasswordsFunction() {}
+
+ExtensionFunction::ResponseAction
+PasswordsPrivateImportPasswordsFunction::Run() {
+  PasswordsPrivateDelegate* delegate =
+      PasswordsPrivateDelegateFactory::GetForBrowserContext(browser_context(),
+                                                            true /* create */);
+  delegate->ImportPasswords(GetAssociatedWebContents());
+  return RespondNow(NoArguments());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PasswordsPrivateExportPasswordsFunction
+
+PasswordsPrivateExportPasswordsFunction::
+    ~PasswordsPrivateExportPasswordsFunction() {}
+
+ExtensionFunction::ResponseAction
+PasswordsPrivateExportPasswordsFunction::Run() {
+  PasswordsPrivateDelegate* delegate =
+      PasswordsPrivateDelegateFactory::GetForBrowserContext(browser_context(),
+                                                            true /* create */);
+  delegate->ExportPasswords(GetAssociatedWebContents());
+  return RespondNow(NoArguments());
+}
+
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.h b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.h
index dab11b9644d..59f7e3caf2a 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.h
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_api.h
@@ -48,6 +48,25 @@ class PasswordsPrivateRemovePasswordExceptionFunction :
   DISALLOW_COPY_AND_ASSIGN(PasswordsPrivateRemovePasswordExceptionFunction);
 };
 
+class PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction
+    : public UIThreadExtensionFunction {
+ public:
+  PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction() {}
+  DECLARE_EXTENSION_FUNCTION(
+      "passwordsPrivate.undoRemoveSavedPasswordOrException",
+      PASSWORDSPRIVATE_UNDOREMOVESAVEDPASSWORDOREXCEPTION);
+
+ protected:
+  ~PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction() override;
+
+  // ExtensionFunction overrides.
+  ResponseAction Run() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(
+      PasswordsPrivateUndoRemoveSavedPasswordOrExceptionFunction);
+};
+
 class PasswordsPrivateRequestPlaintextPasswordFunction :
     public UIThreadExtensionFunction {
  public:
@@ -105,6 +124,40 @@ class PasswordsPrivateGetPasswordExceptionListFunction
   DISALLOW_COPY_AND_ASSIGN(PasswordsPrivateGetPasswordExceptionListFunction);
 };
 
+class PasswordsPrivateImportPasswordsFunction
+    : public UIThreadExtensionFunction {
+ public:
+  PasswordsPrivateImportPasswordsFunction() {}
+  DECLARE_EXTENSION_FUNCTION("passwordsPrivate.importPasswords",
+                             PASSWORDSPRIVATE_IMPORTPASSWORDS);
+
+ protected:
+  ~PasswordsPrivateImportPasswordsFunction() override;
+
+  // ExtensionFunction overrides.
+  ResponseAction Run() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PasswordsPrivateImportPasswordsFunction);
+};
+
+class PasswordsPrivateExportPasswordsFunction
+    : public UIThreadExtensionFunction {
+ public:
+  PasswordsPrivateExportPasswordsFunction() {}
+  DECLARE_EXTENSION_FUNCTION("passwordsPrivate.exportPasswords",
+                             PASSWORDSPRIVATE_EXPORTPASSWORDS);
+
+ protected:
+  ~PasswordsPrivateExportPasswordsFunction() override;
+
+  // ExtensionFunction overrides.
+  ResponseAction Run() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PasswordsPrivateExportPasswordsFunction);
+};
+
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_PASSWORDS_PRIVATE_PASSWORDS_PRIVATE_API_H_
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_apitest.cc b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_apitest.cc
index b00abdba45b..09c69a450f0 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_apitest.cc
@@ -9,9 +9,11 @@
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/observer_list.h"
+#include "base/optional.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
+#include "build/build_config.h"
 #include "chrome/browser/extensions/api/passwords_private/passwords_private_delegate.h"
 #include "chrome/browser/extensions/api/passwords_private/passwords_private_delegate_factory.h"
 #include "chrome/browser/extensions/api/passwords_private/passwords_private_event_router.h"
@@ -39,6 +41,7 @@ api::passwords_private::PasswordUiEntry CreateEntry(size_t num) {
   entry.login_pair.urls.link = entry.login_pair.urls.origin;
   entry.login_pair.username = "testName" + std::to_string(num);
   entry.num_characters_in_password = kNumCharactersInPassword;
+  entry.index = num;
   return entry;
 }
 
@@ -47,6 +50,7 @@ api::passwords_private::ExceptionEntry CreateException(size_t num) {
   exception.urls.shown = "exception" + std::to_string(num) + ".com";
   exception.urls.origin = "http://" + exception.urls.shown + "/login";
   exception.urls.link = exception.urls.origin;
+  exception.index = num;
   return exception;
 }
 
@@ -88,47 +92,85 @@ class TestDelegate : public PasswordsPrivateDelegate {
     callback.Run(current_exceptions_);
   }
 
-  void RemoveSavedPassword(const std::string& origin,
-                           const std::string& username) override {
+  void RemoveSavedPassword(size_t index) override {
     if (current_entries_.empty())
       return;
 
     // Since this is just mock data, remove the first entry regardless of
     // the data contained.
+    last_deleted_entry_ = std::move(current_entries_.front());
     current_entries_.erase(current_entries_.begin());
     SendSavedPasswordsList();
   }
 
-  void RemovePasswordException(const std::string& exception_url) override {
-    if (current_exceptions_.empty())
+  void RemovePasswordException(size_t index) override {
+    if (index >= current_exceptions_.size())
       return;
 
     // Since this is just mock data, remove the first entry regardless of
     // the data contained.
+    last_deleted_exception_ = std::move(current_exceptions_.front());
     current_exceptions_.erase(current_exceptions_.begin());
     SendPasswordExceptionsList();
   }
 
-  void RequestShowPassword(const std::string& origin,
-                           const std::string& username,
+  // Simplified version of undo logic, only use for testing.
+  void UndoRemoveSavedPasswordOrException() override {
+    if (last_deleted_entry_) {
+      current_entries_.insert(current_entries_.begin(),
+                              std::move(*last_deleted_entry_));
+      last_deleted_entry_ = base::nullopt;
+      SendSavedPasswordsList();
+    } else if (last_deleted_exception_) {
+      current_exceptions_.insert(current_exceptions_.begin(),
+                                 std::move(*last_deleted_exception_));
+      last_deleted_exception_ = base::nullopt;
+      SendPasswordExceptionsList();
+    }
+  }
+
+  void RequestShowPassword(size_t index,
                            content::WebContents* web_contents) override {
     // Return a mocked password value.
     std::string plaintext_password(kPlaintextPassword);
     PasswordsPrivateEventRouter* router =
         PasswordsPrivateEventRouterFactory::GetForProfile(profile_);
     if (router) {
-      router->OnPlaintextPasswordFetched(origin, username, plaintext_password);
+      if (index >= current_entries_.size())
+        return;
+      router->OnPlaintextPasswordFetched(index, plaintext_password);
     }
   }
 
   void SetProfile(Profile* profile) { profile_ = profile; }
 
+  void ImportPasswords(content::WebContents* web_contents) override {
+    // The testing of password importing itself should be handled via
+    // |PasswordManagerPorter|.
+    importPasswordsTriggered = true;
+  }
+
+  void ExportPasswords(content::WebContents* web_contents) override {
+    // The testing of password exporting itself should be handled via
+    // |PasswordManagerPorter|.
+    exportPasswordsTriggered = true;
+  }
+
+  // Flags for detecting whether import/export operations have been invoked.
+  bool importPasswordsTriggered = false;
+  bool exportPasswordsTriggered = false;
+
  private:
   // The current list of entries/exceptions. Cached here so that when new
   // observers are added, this delegate can send the current lists without
   // having to request them from |password_manager_presenter_| again.
   std::vector<api::passwords_private::PasswordUiEntry> current_entries_;
   std::vector<api::passwords_private::ExceptionEntry> current_exceptions_;
+  // Simplified version of a undo manager that only allows undoing and redoing
+  // the very last deletion.
+  base::Optional<api::passwords_private::PasswordUiEntry> last_deleted_entry_;
+  base::Optional<api::passwords_private::ExceptionEntry>
+      last_deleted_exception_;
   Profile* profile_;
 };
 
@@ -170,6 +212,14 @@ class PasswordsPrivateApiTest : public ExtensionApiTest {
                                kFlagLoadAsComponent);
   }
 
+  bool importPasswordsWasTriggered() {
+    return s_test_delegate_->importPasswordsTriggered;
+  }
+
+  bool exportPasswordsWasTriggered() {
+    return s_test_delegate_->exportPasswordsTriggered;
+  }
+
  private:
   static TestDelegate* s_test_delegate_;
 
@@ -181,12 +231,16 @@ TestDelegate* PasswordsPrivateApiTest::s_test_delegate_ = nullptr;
 
 }  // namespace
 
-IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, RemoveSavedPassword) {
-  EXPECT_TRUE(RunPasswordsSubtest("removeSavedPassword")) << message_;
+IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest,
+                       RemoveAndUndoRemoveSavedPassword) {
+  EXPECT_TRUE(RunPasswordsSubtest("removeAndUndoRemoveSavedPassword"))
+      << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, RemovePasswordException) {
-  EXPECT_TRUE(RunPasswordsSubtest("removePasswordException")) << message_;
+IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest,
+                       RemoveAndUndoRemovePasswordException) {
+  EXPECT_TRUE(RunPasswordsSubtest("removeAndUndoRemovePasswordException"))
+      << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, RequestPlaintextPassword) {
@@ -201,4 +255,30 @@ IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, GetPasswordExceptionList) {
   EXPECT_TRUE(RunPasswordsSubtest("getPasswordExceptionList")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, ImportPasswords) {
+  EXPECT_FALSE(importPasswordsWasTriggered());
+  EXPECT_TRUE(RunPasswordsSubtest("importPasswords")) << message_;
+
+  // TODO(crbug.com/177163): Extension subtests are currently skipped on
+  // Windows, which leads to the import passwords function never being
+  // triggered, causing the test to fail, so the check is currently skipped in
+  // this case.
+  if (!ExtensionApiTest::ExtensionSubtestsAreSkipped()) {
+    EXPECT_TRUE(importPasswordsWasTriggered());
+  }
+}
+
+IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, ExportPasswords) {
+  EXPECT_FALSE(exportPasswordsWasTriggered());
+  EXPECT_TRUE(RunPasswordsSubtest("exportPasswords")) << message_;
+
+  // TODO(crbug.com/177163): Extension subtests are currently skipped on
+  // Windows, which leads to the import passwords function never being
+  // triggered, causing the test to fail, so the check is currently skipped in
+  // this case.
+  if (!ExtensionApiTest::ExtensionSubtestsAreSkipped()) {
+    EXPECT_TRUE(exportPasswordsWasTriggered());
+  }
+}
+
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate.h b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate.h
index 4371b3ad060..4ac97e242d3 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate.h
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate.h
@@ -50,30 +50,34 @@ class PasswordsPrivateDelegate : public KeyedService {
   virtual void GetPasswordExceptionsList(
       const ExceptionEntriesCallback& callback) = 0;
 
-  // Removes the saved password entry corresponding to |origin_url| and
-  // |username|.
-  // |origin_url| The origin for the URL where the password is used; should be
-  //     obtained using CreateUrlCollectionFromForm().origin.
-  // |username| The username used in conjunction with the saved password.
-  virtual void RemoveSavedPassword(
-      const std::string& origin_url, const std::string& username) = 0;
-
-  // Removes the saved password exception entry corresponding to
-  // |exception_url|.
-  // |exception_url| The URL corresponding to the exception to remove; should
-  //     be obtained using CreateUrlCollectionFromForm().origin.
-  virtual void RemovePasswordException(const std::string& exception_url) = 0;
-
-  // Requests the plain text password for entry corresponding to |origin_url|
-  // and |username|.
-  // |origin_url| The origin for the URL where the password is used; should be
-  //     obtained using CreateUrlCollectionFromForm().origin.
-  // |username| The username used in conjunction with the saved password.
-  // |native_window| The Chrome host window; will be used to show an OS-level
-  //     authentication dialog if necessary.
-  virtual void RequestShowPassword(const std::string& origin_url,
-                                   const std::string& username,
+  // Removes the saved password entry corresponding to the |index| generated for
+  // each entry of the password list.
+  // |index| the index created when going over the list of saved passwords.
+  virtual void RemoveSavedPassword(size_t index) = 0;
+
+  // Removes the saved password exception entry corresponding set in the
+  // given |index|
+  // |index| The index for the exception url entry being removed.
+  virtual void RemovePasswordException(size_t index) = 0;
+
+  // Undoes the last removal of a saved password or exception.
+  virtual void UndoRemoveSavedPasswordOrException() = 0;
+
+  // Requests the plain text password for entry corresponding to the |index|
+  // generated for each entry of the password list.
+  // |index| the index created when going over the list of saved passwords.
+  // |web_contents| The web content object used as the UI; will be used to show
+  //     an OS-level authentication dialog if necessary.
+  virtual void RequestShowPassword(size_t index,
                                    content::WebContents* web_contents) = 0;
+
+  // Trigger the password import procedure, allowing the user to select a file
+  // containing passwords to import.
+  virtual void ImportPasswords(content::WebContents* web_contents) = 0;
+
+  // Trigger the password export procedure, allowing the user to save a file
+  // containing their passwords.
+  virtual void ExportPasswords(content::WebContents* web_contents) = 0;
 };
 
 }  // namespace extensions
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 13864f7fb05..ae2f63a90d7 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
@@ -4,6 +4,9 @@
 
 #include "chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.h"
 
+#include <utility>
+
+#include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ -17,20 +20,11 @@
 #include "chrome/grit/generated_resources.h"
 #include "components/password_manager/core/browser/android_affiliation/affiliation_utils.h"
 #include "components/password_manager/core/browser/password_ui_utils.h"
+#include "components/password_manager/core/common/password_manager_features.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/web_contents.h"
 #include "ui/base/l10n/l10n_util.h"
 
-namespace {
-
-std::string LoginPairToMapKey(const std::string& origin_url,
-                              const std::string& username) {
-  // Concatenate origin URL and username to form a unique key.
-  return origin_url + ',' + username;
-}
-
-}  // namespace
-
 namespace extensions {
 
 PasswordsPrivateDelegateImpl::PasswordsPrivateDelegateImpl(Profile* profile)
@@ -76,66 +70,49 @@ void PasswordsPrivateDelegateImpl::GetPasswordExceptionsList(
     get_password_exception_list_callbacks_.push_back(callback);
 }
 
-void PasswordsPrivateDelegateImpl::RemoveSavedPassword(
-    const std::string& origin_url, const std::string& username) {
-  ExecuteFunction(base::Bind(
-      &PasswordsPrivateDelegateImpl::RemoveSavedPasswordInternal,
-      base::Unretained(this),
-      origin_url,
-      username));
+void PasswordsPrivateDelegateImpl::RemoveSavedPassword(size_t index) {
+  ExecuteFunction(
+      base::Bind(&PasswordsPrivateDelegateImpl::RemoveSavedPasswordInternal,
+                 base::Unretained(this), index));
 }
 
-void PasswordsPrivateDelegateImpl::RemoveSavedPasswordInternal(
-    const std::string& origin_url, const std::string& username) {
-  std::string key = LoginPairToMapKey(origin_url, username);
-  if (login_pair_to_index_map_.find(key) == login_pair_to_index_map_.end()) {
-    // If the URL/username pair does not exist in the map, do nothing.
-    return;
-  }
-
-  password_manager_presenter_->RemoveSavedPassword(
-      login_pair_to_index_map_[key]);
+void PasswordsPrivateDelegateImpl::RemoveSavedPasswordInternal(size_t index) {
+  password_manager_presenter_->RemoveSavedPassword(index);
 }
 
-void PasswordsPrivateDelegateImpl::RemovePasswordException(
-    const std::string& exception_url) {
-  ExecuteFunction(base::Bind(
-      &PasswordsPrivateDelegateImpl::RemovePasswordExceptionInternal,
-      base::Unretained(this),
-      exception_url));
+void PasswordsPrivateDelegateImpl::RemovePasswordException(size_t index) {
+  ExecuteFunction(
+      base::Bind(&PasswordsPrivateDelegateImpl::RemovePasswordExceptionInternal,
+                 base::Unretained(this), index));
 }
 
 void PasswordsPrivateDelegateImpl::RemovePasswordExceptionInternal(
-    const std::string& exception_url) {
-  if (exception_url_to_index_map_.find(exception_url) ==
-      exception_url_to_index_map_.end()) {
-    // If the exception URL does not exist in the map, do nothing.
-    return;
-  }
+    size_t index) {
+  password_manager_presenter_->RemovePasswordException(index);
+}
 
-  password_manager_presenter_->RemovePasswordException(
-      exception_url_to_index_map_[exception_url]);
+void PasswordsPrivateDelegateImpl::UndoRemoveSavedPasswordOrException() {
+  ExecuteFunction(base::Bind(
+      &PasswordsPrivateDelegateImpl::UndoRemoveSavedPasswordOrExceptionInternal,
+      base::Unretained(this)));
+}
+
+void PasswordsPrivateDelegateImpl::
+    UndoRemoveSavedPasswordOrExceptionInternal() {
+  password_manager_presenter_->UndoRemoveSavedPasswordOrException();
 }
 
 void PasswordsPrivateDelegateImpl::RequestShowPassword(
-    const std::string& origin_url,
-    const std::string& username,
+    size_t index,
     content::WebContents* web_contents) {
   ExecuteFunction(
       base::Bind(&PasswordsPrivateDelegateImpl::RequestShowPasswordInternal,
-                 base::Unretained(this), origin_url, username, web_contents));
+                 base::Unretained(this), index, web_contents));
 }
 
 void PasswordsPrivateDelegateImpl::RequestShowPasswordInternal(
-    const std::string& origin_url,
-    const std::string& username,
+    size_t index,
     content::WebContents* web_contents) {
-  std::string key = LoginPairToMapKey(origin_url, username);
-  if (login_pair_to_index_map_.find(key) == login_pair_to_index_map_.end()) {
-    // If the URL/username pair does not exist in the map, do nothing.
-    return;
-  }
-
   // Save |web_contents| so that the call to RequestShowPassword() below
   // can use this value by calling GetNativeWindow(). Note: This is safe because
   // GetNativeWindow() will only be called immediately from
@@ -145,8 +122,7 @@ void PasswordsPrivateDelegateImpl::RequestShowPasswordInternal(
   web_contents_ = web_contents;
 
   // Request the password. When it is retrieved, ShowPassword() will be called.
-  password_manager_presenter_->RequestShowPassword(
-      login_pair_to_index_map_[key]);
+  password_manager_presenter_->RequestShowPassword(index);
 }
 
 Profile* PasswordsPrivateDelegateImpl::GetProfile() {
@@ -155,36 +131,29 @@ Profile* PasswordsPrivateDelegateImpl::GetProfile() {
 
 void PasswordsPrivateDelegateImpl::ShowPassword(
     size_t index,
-    const std::string& origin_url,
-    const std::string& username,
     const base::string16& password_value) {
   PasswordsPrivateEventRouter* router =
       PasswordsPrivateEventRouterFactory::GetForProfile(profile_);
   if (router) {
-    router->OnPlaintextPasswordFetched(origin_url, username,
+    router->OnPlaintextPasswordFetched(index,
                                        base::UTF16ToUTF8(password_value));
   }
 }
 
 void PasswordsPrivateDelegateImpl::SetPasswordList(
     const std::vector<std::unique_ptr<autofill::PasswordForm>>& password_list) {
-  // Rebuild |login_pair_to_index_map_| so that it reflects the contents of the
-  // new list.
-  // Also, create a list of PasswordUiEntry objects to send to observers.
-  login_pair_to_index_map_.clear();
+  // Create a list of PasswordUiEntry objects to send to observers.
   current_entries_.clear();
 
   for (size_t i = 0; i < password_list.size(); i++) {
     const auto& form = password_list[i];
     api::passwords_private::UrlCollection urls =
         CreateUrlCollectionFromForm(*form);
-    std::string key =
-        LoginPairToMapKey(urls.origin, base::UTF16ToUTF8(form->username_value));
-    login_pair_to_index_map_[key] = i;
 
     api::passwords_private::PasswordUiEntry entry;
     entry.login_pair.urls = std::move(urls);
     entry.login_pair.username = base::UTF16ToUTF8(form->username_value);
+    entry.index = base::checked_cast<int>(i);
     entry.num_characters_in_password = form->password_value.length();
 
     if (!form->federation_origin.unique()) {
@@ -212,20 +181,17 @@ void PasswordsPrivateDelegateImpl::SetPasswordList(
 void PasswordsPrivateDelegateImpl::SetPasswordExceptionList(
     const std::vector<std::unique_ptr<autofill::PasswordForm>>&
         password_exception_list) {
-  // Rebuild |exception_url_to_index_map_| so that it reflects the contents of
-  // the new list.
-  // Also, create a list of exceptions to send to observers.
-  exception_url_to_index_map_.clear();
+  // Creates a list of exceptions to send to observers.
   current_exceptions_.clear();
 
   for (size_t i = 0; i < password_exception_list.size(); i++) {
     const auto& form = password_exception_list[i];
     api::passwords_private::UrlCollection urls =
         CreateUrlCollectionFromForm(*form);
-    exception_url_to_index_map_[urls.origin] = i;
 
     api::passwords_private::ExceptionEntry current_exception_entry;
     current_exception_entry.urls = std::move(urls);
+    current_exception_entry.index = base::checked_cast<int>(i);
     current_exceptions_.push_back(std::move(current_exception_entry));
   }
 
@@ -242,6 +208,16 @@ void PasswordsPrivateDelegateImpl::SetPasswordExceptionList(
   get_password_exception_list_callbacks_.clear();
 }
 
+void PasswordsPrivateDelegateImpl::ImportPasswords(
+    content::WebContents* web_contents) {
+  password_manager_presenter_->ImportPasswords(web_contents);
+}
+
+void PasswordsPrivateDelegateImpl::ExportPasswords(
+    content::WebContents* web_contents) {
+  password_manager_presenter_->ExportPasswords(web_contents);
+}
+
 #if !defined(OS_ANDROID)
 gfx::NativeWindow PasswordsPrivateDelegateImpl::GetNativeWindow() const {
   DCHECK(web_contents_);
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.h b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.h
index 842eb52a8be..db3af4d4049 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.h
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_delegate_impl.h
@@ -7,7 +7,6 @@
 
 #include <stddef.h>
 
-#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -44,19 +43,18 @@ class PasswordsPrivateDelegateImpl : public PasswordsPrivateDelegate,
   void SendPasswordExceptionsList() override;
   void GetPasswordExceptionsList(
       const ExceptionEntriesCallback& callback) override;
-  void RemoveSavedPassword(
-      const std::string& origin_url, const std::string& username) override;
-  void RemovePasswordException(const std::string& exception_url) override;
-  void RequestShowPassword(const std::string& origin_url,
-                           const std::string& username,
+  void RemoveSavedPassword(size_t index) override;
+  void RemovePasswordException(size_t index) override;
+  void UndoRemoveSavedPasswordOrException() override;
+  void RequestShowPassword(size_t index,
                            content::WebContents* web_contents) override;
+  void ImportPasswords(content::WebContents* web_contents) override;
+  void ExportPasswords(content::WebContents* web_contents) override;
 
   // PasswordUIView implementation.
   Profile* GetProfile() override;
   void ShowPassword(
       size_t index,
-      const std::string& origin_url,
-      const std::string& username,
       const base::string16& plaintext_password) override;
   void SetPasswordList(
       const std::vector<std::unique_ptr<autofill::PasswordForm>>& password_list)
@@ -81,11 +79,10 @@ class PasswordsPrivateDelegateImpl : public PasswordsPrivateDelegate,
   // has been initialized or by deferring it until initialization has completed.
   void ExecuteFunction(const base::Closure& callback);
 
-  void RemoveSavedPasswordInternal(
-      const std::string& origin_url, const std::string& username);
-  void RemovePasswordExceptionInternal(const std::string& exception_url);
-  void RequestShowPasswordInternal(const std::string& origin_url,
-                                   const std::string& username,
+  void RemoveSavedPasswordInternal(size_t index);
+  void RemovePasswordExceptionInternal(size_t index);
+  void UndoRemoveSavedPasswordOrExceptionInternal();
+  void RequestShowPasswordInternal(size_t index,
                                    content::WebContents* web_contents);
 
   // Not owned by this class.
@@ -118,14 +115,6 @@ class PasswordsPrivateDelegateImpl : public PasswordsPrivateDelegate,
   // NativeWindow for the window where the API was called.
   content::WebContents* web_contents_;
 
-  // Map from origin URL and username to the index of |password_list_| at which
-  // the corresponding entry resides.
-  std::map<std::string, size_t> login_pair_to_index_map_;
-
-  // Map from password exception URL to the index of |password_exception_list_|
-  // at which the correponding entry resides.
-  std::map<std::string, size_t> exception_url_to_index_map_;
-
   DISALLOW_COPY_AND_ASSIGN(PasswordsPrivateDelegateImpl);
 };
 
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.cc b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.cc
index b5a22d86912..ca05c357e70 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.cc
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.cc
@@ -70,12 +70,10 @@ void PasswordsPrivateEventRouter::SendPasswordExceptionListToListeners() {
 }
 
 void PasswordsPrivateEventRouter::OnPlaintextPasswordFetched(
-        const std::string& origin_url,
-        const std::string& username,
-        const std::string& plaintext_password) {
+    size_t index,
+    const std::string& plaintext_password) {
   api::passwords_private::PlaintextPasswordEventParameters params;
-  params.login_pair.urls.origin = origin_url;
-  params.login_pair.username = username;
+  params.index = index;
   params.plaintext_password = plaintext_password;
 
   std::unique_ptr<base::ListValue> event_value(new base::ListValue);
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.h b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.h
index 5ea04d7a8da..b1d529327d2 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.h
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_event_router.h
@@ -36,13 +36,10 @@ class PasswordsPrivateEventRouter : public KeyedService {
       const std::vector<api::passwords_private::ExceptionEntry>& exceptions);
 
   // Notifies listeners after fetching a plain-text password.
-  // |origin_url| The origin which the password is saved for.
-  // |username| The username that this password belongs to.
+  // |index| the index for the password entry being shown.
   // |plaintext_password| The human-readable password.
-  void OnPlaintextPasswordFetched(
-      const std::string& origin_url,
-      const std::string& username,
-      const std::string& plaintext_password);
+  void OnPlaintextPasswordFetched(size_t index,
+                                  const std::string& plaintext_password);
 
  protected:
   explicit PasswordsPrivateEventRouter(content::BrowserContext* context);
diff --git a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_utils.h b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_utils.h
index 85e29369265..2f3a787844f 100644
--- a/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_utils.h
+++ b/chromium/chrome/browser/extensions/api/passwords_private/passwords_private_utils.h
@@ -18,6 +18,7 @@ namespace extensions {
 // well as a URL that is linked to.
 api::passwords_private::UrlCollection CreateUrlCollectionFromForm(
     const autofill::PasswordForm& form);
-}
+
+}  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_PASSWORDS_PRIVATE_PASSWORDS_PRIVATE_UTILS_H_
diff --git a/chromium/chrome/browser/extensions/api/platform_keys/verify_trust_api.cc b/chromium/chrome/browser/extensions/api/platform_keys/verify_trust_api.cc
index 3bc152700ed..e1e4d05bc8e 100644
--- a/chromium/chrome/browser/extensions/api/platform_keys/verify_trust_api.cc
+++ b/chromium/chrome/browser/extensions/api/platform_keys/verify_trust_api.cc
@@ -25,7 +25,7 @@ namespace extensions {
 namespace {
 
 base::LazyInstance<BrowserContextKeyedAPIFactory<VerifyTrustAPI>>::Leaky
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_verify_trust_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 const char kErrorEmptyCertificateChain[] =
     "Server certificate chain must not be empty.";
@@ -78,7 +78,7 @@ class VerifyTrustAPI::IOPart {
 // static
 BrowserContextKeyedAPIFactory<VerifyTrustAPI>*
 VerifyTrustAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_verify_trust_api_factory.Pointer();
 }
 
 template <>
diff --git a/chromium/chrome/browser/extensions/api/preference/preference_api.cc b/chromium/chrome/browser/extensions/api/preference/preference_api.cc
index c16442b8097..b80fa289d37 100644
--- a/chromium/chrome/browser/extensions/api/preference/preference_api.cc
+++ b/chromium/chrome/browser/extensions/api/preference/preference_api.cc
@@ -563,14 +563,13 @@ void PreferenceAPI::Shutdown() {
   content_settings_store()->RemoveObserver(this);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<PreferenceAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<PreferenceAPI>>::
+    DestructorAtExit g_preference_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<PreferenceAPI>*
 PreferenceAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_preference_api_factory.Pointer();
 }
 
 // static
@@ -765,7 +764,7 @@ ExtensionFunction::ResponseAction SetPreferenceFunction::Run() {
     EXTENSION_FUNCTION_VALIDATE(!bad_message);
     return RespondNow(Error(error));
   }
-  EXTENSION_FUNCTION_VALIDATE(browser_pref_value->GetType() == pref->GetType());
+  EXTENSION_FUNCTION_VALIDATE(browser_pref_value->type() == pref->GetType());
 
   // Validate also that the stored value can be converted back by the
   // transformer.
diff --git a/chromium/chrome/browser/extensions/api/preference/preference_apitest.cc b/chromium/chrome/browser/extensions/api/preference/preference_apitest.cc
index 69e7e5d0e07..631a0bb0dc4 100644
--- a/chromium/chrome/browser/extensions/api/preference/preference_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/preference/preference_apitest.cc
@@ -13,8 +13,6 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_apitest.h"
-#include "chrome/browser/lifetime/keep_alive_types.h"
-#include "chrome/browser/lifetime/scoped_keep_alive.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ -23,6 +21,8 @@
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/content_settings/core/common/pref_names.h"
+#include "components/keep_alive_registry/keep_alive_types.h"
+#include "components/keep_alive_registry/scoped_keep_alive.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing/common/safe_browsing_prefs.h"
diff --git a/chromium/chrome/browser/extensions/api/processes/processes_api.cc b/chromium/chrome/browser/extensions/api/processes/processes_api.cc
index 910f103b21b..63c005ec295 100644
--- a/chromium/chrome/browser/extensions/api/processes/processes_api.cc
+++ b/chromium/chrome/browser/extensions/api/processes/processes_api.cc
@@ -7,6 +7,9 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
+#include <set>
+#include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram_macros.h"
@@ -20,6 +23,7 @@
 #include "chrome/common/extensions/api/processes.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/child_process_data.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
@@ -137,8 +141,8 @@ void FillProcessData(
   if (!include_optional)
     return;
 
-  out_process->cpu.reset(new double(task_manager->GetCpuUsage(id)));
-
+  out_process->cpu.reset(
+      new double(task_manager->GetPlatformIndependentCPUUsage(id)));
   out_process->network.reset(new double(static_cast<double>(
       task_manager->GetProcessTotalNetworkUsage(id))));
 
@@ -459,7 +463,9 @@ ExtensionFunction::ResponseAction ProcessesGetProcessIdForTabFunction::Run() {
                             base::IntToString(tab_id)));
   }
 
-  const int process_id = contents->GetRenderProcessHost()->GetID();
+  // TODO(https://crbug.com/767563): chrome.processes.getProcessIdForTab API
+  // incorrectly assumes a *single* renderer process per tab.
+  const int process_id = contents->GetMainFrame()->GetProcess()->GetID();
   return RespondNow(ArgumentList(
       api::processes::GetProcessIdForTab::Results::Create(process_id)));
 }
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 d4c0b762a46..61756b241fb 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
@@ -39,6 +39,7 @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "components/user_manager/user_manager.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
 #endif
 
 using extensions::Extension;
@@ -305,9 +306,8 @@ bool ChromeRuntimeAPIDelegate::GetPlatformInfo(PlatformInfo* info) {
 bool ChromeRuntimeAPIDelegate::RestartDevice(std::string* error_message) {
 #if defined(OS_CHROMEOS)
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp()) {
-    chromeos::DBusThreadManager::Get()
-        ->GetPowerManagerClient()
-        ->RequestRestart();
+    chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart(
+        power_manager::REQUEST_RESTART_OTHER, "chrome.runtime API");
     return true;
   }
 #endif
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 30334b55a15..355d8f518da 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
@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <deque>
 #include <memory>
 #include <set>
 #include <utility>
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 4d8d4f49a7d..6eb32c1c891 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
@@ -147,13 +147,13 @@ void ScreenlockPrivateEventRouter::DispatchEvent(
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<
-    ScreenlockPrivateEventRouter>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+    ScreenlockPrivateEventRouter>>::DestructorAtExit
+    g_screenlock_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<ScreenlockPrivateEventRouter>*
 ScreenlockPrivateEventRouter::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_screenlock_private_api_factory.Pointer();
 }
 
 void ScreenlockPrivateEventRouter::Shutdown() {
diff --git a/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc b/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc
index 83f3b82888a..1c372a7433d 100644
--- a/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc
+++ b/chromium/chrome/browser/extensions/api/sessions/sessions_api.cc
@@ -593,13 +593,12 @@ void SessionsAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<SessionsAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<SessionsAPI>>::
+    DestructorAtExit g_sessions_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 BrowserContextKeyedAPIFactory<SessionsAPI>*
 SessionsAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_sessions_api_factory.Pointer();
 }
 
 void SessionsAPI::OnListenerAdded(const EventListenerInfo& details) {
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 4305f6a3010..0a2343bc02c 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
@@ -32,7 +32,8 @@ namespace extensions {
 namespace {
 
 base::LazyInstance<BrowserContextKeyedAPIFactory<SettingsOverridesAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_settings_overrides_api_factory =
+        LAZY_INSTANCE_INITIALIZER;
 
 const char kManyStartupPagesWarning[] = "* specifies more than 1 startup URL. "
     "All but the first will be ignored.";
@@ -72,10 +73,6 @@ std::unique_ptr<TemplateURLData> ConvertSearchProvider(
     data->suggestions_url =
         SubstituteInstallParam(*search_provider.suggest_url, install_parameter);
   }
-  if (search_provider.instant_url) {
-    data->instant_url =
-        SubstituteInstallParam(*search_provider.instant_url, install_parameter);
-  }
   if (search_provider.image_url) {
     data->image_url =
         SubstituteInstallParam(*search_provider.image_url, install_parameter);
@@ -85,8 +82,6 @@ std::unique_ptr<TemplateURLData> ConvertSearchProvider(
   if (search_provider.suggest_url_post_params)
     data->suggestions_url_post_params =
         *search_provider.suggest_url_post_params;
-  if (search_provider.instant_url_post_params)
-    data->instant_url_post_params = *search_provider.instant_url_post_params;
   if (search_provider.image_url_post_params)
     data->image_url_post_params = *search_provider.image_url_post_params;
   if (search_provider.favicon_url) {
@@ -126,7 +121,7 @@ SettingsOverridesAPI::~SettingsOverridesAPI() {
 
 BrowserContextKeyedAPIFactory<SettingsOverridesAPI>*
 SettingsOverridesAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_settings_overrides_api_factory.Pointer();
 }
 
 void SettingsOverridesAPI::SetPref(const std::string& extension_id,
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 a5ff980b6f4..56d30db8f51 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
@@ -36,11 +36,9 @@ std::unique_ptr<TemplateURLData> TestExtensionSearchEngine(PrefService* prefs) {
   result->SetURL("http://www.foo.de/s?q={searchTerms}&id=10");
   result->favicon_url = GURL("http://www.foo.de/favicon.ico?id=10");
   result->suggestions_url = "http://www.foo.de/suggest?q={searchTerms}&id=10";
-  result->instant_url = "http://www.foo.de/instant?q={searchTerms}&id=10";
   result->image_url = "http://www.foo.de/image?q={searchTerms}&id=10";
   result->search_url_post_params = "search_lang=de";
   result->suggestions_url_post_params = "suggest_lang=de";
-  result->instant_url_post_params = "instant_lang=de";
   result->image_url_post_params = "image_lang=de";
   result->alternate_urls.push_back("http://www.moo.de/s?q={searchTerms}&id=10");
   result->alternate_urls.push_back("http://www.noo.de/s?q={searchTerms}&id=10");
@@ -51,8 +49,6 @@ std::unique_ptr<TemplateURLData> TestExtensionSearchEngine(PrefService* prefs) {
           prefs, kTestExtensionPrepopulatedId);
   // Values below do not exist in extension manifest and are taken from
   // prepopulated engine with prepopulated_id set in extension manifest.
-  result->search_terms_replacement_key =
-      prepopulated->search_terms_replacement_key;
   result->contextual_search_url = prepopulated->contextual_search_url;
   result->new_tab_url = prepopulated->new_tab_url;
   return result;
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 012d5eb29e9..af6fabf4c23 100644
--- a/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc
+++ b/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc
@@ -42,6 +42,7 @@
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/system/timezone_util.h"
 #include "chromeos/settings/cros_settings_names.h"
+#include "components/arc/arc_prefs.h"
 #include "ui/chromeos/events/pref_names.h"
 #endif
 
@@ -191,8 +192,6 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() {
   // Search page.
   (*s_whitelist)[DefaultSearchManager::kDefaultSearchProviderDataPrefName] =
       settings_private::PrefType::PREF_TYPE_DICTIONARY;
-  (*s_whitelist)[::prefs::kGoogleNowLauncherEnabled] =
-      settings_private::PrefType::PREF_TYPE_BOOLEAN;
 
   // Site Settings prefs.
   (*s_whitelist)[::prefs::kBlockThirdPartyCookies] =
@@ -205,22 +204,34 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() {
   // Clear browsing data settings.
   (*s_whitelist)[browsing_data::prefs::kDeleteBrowsingHistory] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
+  (*s_whitelist)[browsing_data::prefs::kDeleteBrowsingHistoryBasic] =
+      settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteDownloadHistory] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteCache] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
+  (*s_whitelist)[browsing_data::prefs::kDeleteCacheBasic] =
+      settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteCookies] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
+  (*s_whitelist)[browsing_data::prefs::kDeleteCookiesBasic] =
+      settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeletePasswords] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteFormData] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
+  (*s_whitelist)[browsing_data::prefs::kDeleteSiteSettings] =
+      settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteHostedAppsData] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteMediaLicenses] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
   (*s_whitelist)[browsing_data::prefs::kDeleteTimePeriod] =
       settings_private::PrefType::PREF_TYPE_NUMBER;
+  (*s_whitelist)[browsing_data::prefs::kDeleteTimePeriodBasic] =
+      settings_private::PrefType::PREF_TYPE_NUMBER;
+  (*s_whitelist)[browsing_data::prefs::kLastClearBrowsingDataTab] =
+      settings_private::PrefType::PREF_TYPE_NUMBER;
 
 #if defined(OS_CHROMEOS)
   // Accounts / Users / People.
@@ -278,15 +289,15 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() {
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
 
   // Android Apps.
-  (*s_whitelist)[::prefs::kArcEnabled] =
+  (*s_whitelist)[arc::prefs::kArcEnabled] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
 
   // Google Assistant.
-  (*s_whitelist)[::prefs::kArcVoiceInteractionValuePropAccepted] =
+  (*s_whitelist)[arc::prefs::kArcVoiceInteractionValuePropAccepted] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
-  (*s_whitelist)[::prefs::kVoiceInteractionEnabled] =
+  (*s_whitelist)[arc::prefs::kVoiceInteractionEnabled] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
-  (*s_whitelist)[::prefs::kVoiceInteractionContextEnabled] =
+  (*s_whitelist)[arc::prefs::kVoiceInteractionContextEnabled] =
       settings_private::PrefType::PREF_TYPE_BOOLEAN;
 
   // Misc.
@@ -382,6 +393,11 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() {
       settings_private::PrefType::PREF_TYPE_NUMBER;
   (*s_whitelist)[::prefs::kLanguageXkbAutoRepeatInterval] =
       settings_private::PrefType::PREF_TYPE_NUMBER;
+
+  // Multidevice settings.
+  (*s_whitelist)[arc::prefs::kSmsConnectEnabled] =
+      settings_private::PrefType::PREF_TYPE_BOOLEAN;
+
 #else
   (*s_whitelist)[::prefs::kAcceptLanguages] =
       settings_private::PrefType::PREF_TYPE_STRING;
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 2e0e9ee9080..cbca1fbb814 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
@@ -86,12 +86,12 @@ void SignedInDevicesChangeObserver::OnDeviceInfoChange() {
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<SignedInDevicesManager>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_signed_in_devices_manager_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<SignedInDevicesManager>*
 SignedInDevicesManager::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_signed_in_devices_manager_factory.Pointer();
 }
 
 SignedInDevicesManager::SignedInDevicesManager()
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 09633f1f569..e882c99a1f6 100644
--- a/chromium/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/socket/tls_socket_unittest.cc
@@ -5,10 +5,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <memory>
 #include <utility>
 
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "extensions/browser/api/socket/tls_socket.h"
@@ -242,7 +242,7 @@ TEST_F(TLSSocketTest, TestTLSSocketBlockedWriteReentry) {
 
 typedef std::pair<net::CompletionCallback, int> PendingCallback;
 
-class CallbackList : public std::deque<PendingCallback> {
+class CallbackList : public base::circular_deque<PendingCallback> {
  public:
   void append(const net::CompletionCallback& cb, int arg) {
     push_back(std::make_pair(cb, arg));
diff --git a/chromium/chrome/browser/extensions/api/spellcheck/spellcheck_api.cc b/chromium/chrome/browser/extensions/api/spellcheck/spellcheck_api.cc
index 964a4bbdc88..1e24e0c34bb 100644
--- a/chromium/chrome/browser/extensions/api/spellcheck/spellcheck_api.cc
+++ b/chromium/chrome/browser/extensions/api/spellcheck/spellcheck_api.cc
@@ -46,14 +46,13 @@ SpellcheckAPI::SpellcheckAPI(content::BrowserContext* context)
 SpellcheckAPI::~SpellcheckAPI() {
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<SpellcheckAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<SpellcheckAPI>>::
+    DestructorAtExit g_spellcheck_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<SpellcheckAPI>*
 SpellcheckAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_spellcheck_api_factory.Pointer();
 }
 
 void SpellcheckAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
diff --git a/chromium/chrome/browser/extensions/api/storage/managed_value_store_cache.cc b/chromium/chrome/browser/extensions/api/storage/managed_value_store_cache.cc
index 506a8e59ff2..8b4a8467a7e 100644
--- a/chromium/chrome/browser/extensions/api/storage/managed_value_store_cache.cc
+++ b/chromium/chrome/browser/extensions/api/storage/managed_value_store_cache.cc
@@ -14,7 +14,6 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
-#include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/extensions/api/storage/policy_value_store.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
@@ -27,6 +26,7 @@
 #include "components/policy/core/common/schema_registry.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/storage/backend_task_runner.h"
+#include "extensions/browser/extension_file_task_runner.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
@@ -55,9 +55,6 @@ namespace storage = api::storage;
 
 namespace {
 
-const char kLoadSchemasBackgroundTaskTokenName[] =
-    "load_managed_storage_schemas_token";
-
 // Only extension settings are stored in the managed namespace - not apps.
 const ValueStoreFactory::ModelType kManagedModelType =
     ValueStoreFactory::ModelType::EXTENSION;
@@ -95,7 +92,7 @@ class ManagedValueStoreCache::ExtensionTracker
 
   // Loads the schemas of the |extensions| and passes a ComponentMap to
   // Register().
-  static void LoadSchemasOnBlockingPool(
+  static void LoadSchemasOnFileTaskRunner(
       std::unique_ptr<ExtensionSet> extensions,
       base::WeakPtr<ExtensionTracker> self);
   void Register(const policy::ComponentMap* components);
@@ -175,10 +172,9 @@ void ManagedValueStoreCache::ExtensionTracker::LoadSchemas(
       added->Remove(to_remove);
   }
 
-  // Load the schema files in a background thread.
-  BrowserThread::PostBlockingPoolSequencedTask(
-      kLoadSchemasBackgroundTaskTokenName, FROM_HERE,
-      base::BindOnce(&ExtensionTracker::LoadSchemasOnBlockingPool,
+  GetExtensionFileTaskRunner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&ExtensionTracker::LoadSchemasOnFileTaskRunner,
                      base::Passed(&added), weak_factory_.GetWeakPtr()));
 }
 
@@ -188,7 +184,7 @@ bool ManagedValueStoreCache::ExtensionTracker::UsesManagedStorage(
 }
 
 // static
-void ManagedValueStoreCache::ExtensionTracker::LoadSchemasOnBlockingPool(
+void ManagedValueStoreCache::ExtensionTracker::LoadSchemasOnFileTaskRunner(
     std::unique_ptr<ExtensionSet> extensions,
     base::WeakPtr<ExtensionTracker> self) {
   base::ThreadRestrictions::AssertIOAllowed();
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 9f0d24a8578..a1512448ac7 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
@@ -50,7 +50,7 @@ class MutablePolicyValueStore : public PolicyValueStore {
   explicit MutablePolicyValueStore(const base::FilePath& path)
       : PolicyValueStore(
             kTestExtensionId,
-            make_scoped_refptr(new SettingsObserverList()),
+            base::MakeRefCounted<SettingsObserverList>(),
             base::MakeUnique<LeveldbValueStore>(kDatabaseUMAClientName, path)) {
   }
   ~MutablePolicyValueStore() override {}
@@ -117,7 +117,7 @@ class PolicyValueStoreTest : public testing::Test {
         FROM_HERE,
         base::Bind(&PolicyValueStoreTest::SetCurrentPolicyOnBackendSequence,
                    base::Unretained(this), base::Passed(policies.DeepCopy())));
-    content::RunAllBlockingPoolTasksUntilIdle();
+    content::RunAllTasksUntilIdle();
   }
 
   void SetCurrentPolicyOnBackendSequence(
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 2e8594e7c43..0e42107daa4 100644
--- a/chromium/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
+++ b/chromium/chrome/browser/extensions/api/storage/settings_sync_unittest.cc
@@ -107,7 +107,7 @@ class MockSyncChangeProcessor : public syncer::SyncChangeProcessor {
 
   // syncer::SyncChangeProcessor implementation.
   syncer::SyncError ProcessSyncChanges(
-      const tracked_objects::Location& from_here,
+      const base::Location& from_here,
       const syncer::SyncChangeList& change_list) override {
     if (fail_all_requests_) {
       return syncer::SyncError(
@@ -205,7 +205,7 @@ class ExtensionSettingsSyncTest : public testing::Test {
     frontend_.reset();
     profile_.reset();
     // Execute any pending deletion tasks.
-    content::RunAllBlockingPoolTasksUntilIdle();
+    content::RunAllTasksUntilIdle();
   }
 
  protected:
@@ -256,11 +256,11 @@ class ExtensionSettingsSyncTest : public testing::Test {
   }
 
   template <typename Func>
-  void PostOnBackendSequenceAndWait(const tracked_objects::Location& from_here,
+  void PostOnBackendSequenceAndWait(const base::Location& from_here,
                                     Func func) {
     GetBackendTaskRunner()->PostTask(
         from_here, base::Bind(&ExtensionSettingsSyncTest::RunFunc<Func>, func));
-    content::RunAllBlockingPoolTasksUntilIdle();
+    content::RunAllTasksUntilIdle();
   }
 
   // Needed so that the DCHECKs for running on FILE or UI threads pass.
@@ -1471,7 +1471,7 @@ TEST_F(ExtensionSettingsSyncTest, MAYBE_UnlimitedStorageForLocalButNotSync) {
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
-  content::RunAllBlockingPoolTasksUntilIdle();
+  content::RunAllTasksUntilIdle();
 }
 
 }  // namespace extensions
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 86aa995c21c..73ab825fe43 100644
--- a/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.cc
+++ b/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.cc
@@ -227,7 +227,7 @@ syncer::SyncMergeResult SyncStorageBackend::MergeDataAndStartSyncing(
 }
 
 syncer::SyncError SyncStorageBackend::ProcessSyncChanges(
-    const tracked_objects::Location& from_here,
+    const base::Location& from_here,
     const syncer::SyncChangeList& sync_changes) {
   DCHECK(IsOnBackendSequence());
   DCHECK(sync_processor_.get());
diff --git a/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.h b/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.h
index e3b61ed4fdd..6eeaadbb75f 100644
--- a/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.h
+++ b/chromium/chrome/browser/extensions/api/storage/sync_storage_backend.h
@@ -55,7 +55,7 @@ class SyncStorageBackend : public syncer::SyncableService {
       std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
       std::unique_ptr<syncer::SyncErrorFactory> sync_error_factory) override;
   syncer::SyncError ProcessSyncChanges(
-      const tracked_objects::Location& from_here,
+      const base::Location& from_here,
       const syncer::SyncChangeList& change_list) override;
   void StopSyncing(syncer::ModelType type) override;
 
diff --git a/chromium/chrome/browser/extensions/api/streams_private/streams_private_api.cc b/chromium/chrome/browser/extensions/api/streams_private/streams_private_api.cc
index 286b0bab0aa..0e813de0dca 100644
--- a/chromium/chrome/browser/extensions/api/streams_private/streams_private_api.cc
+++ b/chromium/chrome/browser/extensions/api/streams_private/streams_private_api.cc
@@ -182,12 +182,12 @@ void StreamsPrivateAbortFunction::OnClose() {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<StreamsPrivateAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_streams_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<StreamsPrivateAPI>*
 StreamsPrivateAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_streams_private_api_factory.Pointer();
 }
 
 }  // namespace extensions
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 09f07b94b4d..83f5cd6108e 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
@@ -29,12 +29,12 @@ namespace extensions {
 
 static base::LazyInstance<
     BrowserContextKeyedAPIFactory<ExtensionSyncEventObserver>>::DestructorAtExit
-    g_factory = LAZY_INSTANCE_INITIALIZER;
+    g_extension_sync_event_observer_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<ExtensionSyncEventObserver>*
 ExtensionSyncEventObserver::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_extension_sync_event_observer_factory.Pointer();
 }
 
 ExtensionSyncEventObserver::ExtensionSyncEventObserver(
diff --git a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_browsertest.cc b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_browsertest.cc
index 34c2ace5d41..4a19a726f23 100644
--- a/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_browsertest.cc
+++ b/chromium/chrome/browser/extensions/api/sync_file_system/sync_file_system_browsertest.cc
@@ -25,8 +25,7 @@
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "storage/browser/quota/quota_manager.h"
-#include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
-#include "third_party/leveldatabase/src/include/leveldb/env.h"
+#include "third_party/leveldatabase/leveldb_chrome.h"
 
 namespace sync_file_system {
 
@@ -71,7 +70,7 @@ class SyncFileSystemTest : public extensions::PlatformAppBrowserTest,
   }
 
   void SetUpOnMainThread() override {
-    in_memory_env_.reset(leveldb::NewMemEnv(leveldb::Env::Default()));
+    in_memory_env_.reset(leveldb_chrome::NewMemEnv(leveldb::Env::Default()));
     extensions::PlatformAppBrowserTest::SetUpOnMainThread();
     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
 
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 8dbdcf8a265..59fb5e4b2f5 100644
--- a/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.cc
+++ b/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.cc
@@ -5,10 +5,13 @@
 #include "chrome/browser/extensions/api/tab_capture/offscreen_tab.h"
 
 #include <algorithm>
+#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/profiles/profile.h"
@@ -37,6 +40,10 @@ 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 {
@@ -56,6 +63,13 @@ 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,
@@ -120,9 +134,11 @@ OffscreenTab::OffscreenTab(OffscreenTabsOwner* owner)
       content_capture_was_detected_(false),
       navigation_policy_(new NavigationPolicy) {
   DCHECK(profile_);
+  g_offscreen_profiles.Get().push_back(profile_.get());
 }
 
 OffscreenTab::~OffscreenTab() {
+  base::Erase(g_offscreen_profiles.Get(), profile_.get());
   DVLOG(1) << "Destroying OffscreenTab for start_url=" << start_url_.spec();
 }
 
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 75ad96ed9f8..9e313241ff3 100644
--- a/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.h
+++ b/chromium/chrome/browser/extensions/api/tab_capture/offscreen_tab.h
@@ -44,6 +44,10 @@ 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
diff --git a/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_apitest.cc b/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_apitest.cc
index 4933e36328f..28b4d8a2f72 100644
--- a/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/tab_capture/tab_capture_apitest.cc
@@ -202,6 +202,8 @@ IN_PROC_BROWSER_TEST_F(TabCaptureApiPixelTest, OffscreenTabEndToEnd) {
   AddExtensionToCommandLineWhitelist();
   ASSERT_TRUE(RunExtensionSubtest("tab_capture", "offscreen_end_to_end.html"))
       << message_;
+  // Verify that offscreen profile has been destroyed.
+  ASSERT_FALSE(profile()->HasOffTheRecordProfile());
 }
 
 // Tests that off-screen tabs can't do evil things (e.g., access local files).
@@ -213,6 +215,8 @@ IN_PROC_BROWSER_TEST_F(TabCaptureApiPixelTest, OffscreenTabEvilTests) {
   AddExtensionToCommandLineWhitelist();
   ASSERT_TRUE(RunExtensionSubtest("tab_capture", "offscreen_evil_tests.html"))
       << message_;
+  // Verify that offscreen profile has been destroyed.
+  ASSERT_FALSE(profile()->HasOffTheRecordProfile());
 }
 
 // http://crbug.com/177163
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 3e096dfdd73..5df6422ec0c 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
@@ -258,12 +258,12 @@ TabCaptureRegistry* TabCaptureRegistry::Get(content::BrowserContext* context) {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<TabCaptureRegistry>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_tab_capture_registry_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<TabCaptureRegistry>*
 TabCaptureRegistry::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_tab_capture_registry_factory.Pointer();
 }
 
 void TabCaptureRegistry::GetCapturedTabs(
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 d6a16b00d8a..d9d98896180 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.cc
@@ -117,8 +117,7 @@ void TabsEventRouter::TabEntry::NavigationEntryCommitted(
   router_->TabUpdated(this, std::move(changed_property_names));
 }
 
-void TabsEventRouter::TabEntry::TitleWasSet(content::NavigationEntry* entry,
-                                            bool explicit_set) {
+void TabsEventRouter::TabEntry::TitleWasSet(content::NavigationEntry* entry) {
   std::set<std::string> changed_property_names;
   changed_property_names.insert(tabs_constants::kTitleKey);
   router_->TabUpdated(this, std::move(changed_property_names));
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 c100285f625..e76429a521d 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.h
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_event_router.h
@@ -169,8 +169,7 @@ class TabsEventRouter : public TabStripModelObserver,
     // content::WebContentsObserver:
     void NavigationEntryCommitted(
         const content::LoadCommittedDetails& load_details) override;
-    void TitleWasSet(content::NavigationEntry* entry,
-                     bool explicit_set) override;
+    void TitleWasSet(content::NavigationEntry* entry) override;
     void WebContentsDestroyed() override;
 
    private:
diff --git a/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc b/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc
index a761f6b73f6..f503485727a 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_test.cc
@@ -1189,7 +1189,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTab) {
   int duplicate_tab_window_id = GetTabWindowId(duplicate_result.get());
   int duplicate_tab_index =
       api_test_utils::GetInteger(duplicate_result.get(), "index");
-  EXPECT_EQ(base::Value::Type::DICTIONARY, duplicate_result->GetType());
+  EXPECT_EQ(base::Value::Type::DICTIONARY, duplicate_result->type());
   // Duplicate tab id should be different from the original tab id.
   EXPECT_NE(tab_id, duplicate_tab_id);
   EXPECT_EQ(window_id, duplicate_tab_window_id);
@@ -1226,7 +1226,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTabNoPermission) {
   int duplicate_tab_window_id = GetTabWindowId(duplicate_result.get());
   int duplicate_tab_index =
       api_test_utils::GetInteger(duplicate_result.get(), "index");
-  EXPECT_EQ(base::Value::Type::DICTIONARY, duplicate_result->GetType());
+  EXPECT_EQ(base::Value::Type::DICTIONARY, duplicate_result->type());
   // Duplicate tab id should be different from the original tab id.
   EXPECT_NE(tab_id, duplicate_tab_id);
   EXPECT_EQ(window_id, duplicate_tab_window_id);
diff --git a/chromium/chrome/browser/extensions/api/tabs/tabs_windows_api.cc b/chromium/chrome/browser/extensions/api/tabs/tabs_windows_api.cc
index da01aea1134..cd08ee564d0 100644
--- a/chromium/chrome/browser/extensions/api/tabs/tabs_windows_api.cc
+++ b/chromium/chrome/browser/extensions/api/tabs/tabs_windows_api.cc
@@ -68,13 +68,12 @@ void TabsWindowsAPI::Shutdown() {
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
-static base::LazyInstance<
-    BrowserContextKeyedAPIFactory<TabsWindowsAPI>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<BrowserContextKeyedAPIFactory<TabsWindowsAPI>>::
+    DestructorAtExit g_tabs_windows_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 BrowserContextKeyedAPIFactory<TabsWindowsAPI>*
 TabsWindowsAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_tabs_windows_api_factory.Pointer();
 }
 
 void TabsWindowsAPI::OnListenerAdded(const EventListenerInfo& details) {
diff --git a/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc b/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc
index 6da975d1720..251299b8237 100644
--- a/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc
+++ b/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc
@@ -21,6 +21,8 @@
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/common/url_constants.h"
 #include "components/user_manager/user_manager.h"
+#include "extensions/browser/event_router.h"
+#include "extensions/common/api/virtual_keyboard.h"
 #include "extensions/common/api/virtual_keyboard_private.h"
 #include "media/audio/audio_system.h"
 #include "ui/aura/window_tree_host.h"
@@ -60,8 +62,9 @@ keyboard::KeyboardState getKeyboardStateEnum(
 
 namespace extensions {
 
-ChromeVirtualKeyboardDelegate::ChromeVirtualKeyboardDelegate()
-    : weak_factory_(this) {
+ChromeVirtualKeyboardDelegate::ChromeVirtualKeyboardDelegate(
+    content::BrowserContext* browser_context)
+    : browser_context_(browser_context), weak_factory_(this) {
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
@@ -70,11 +73,19 @@ ChromeVirtualKeyboardDelegate::~ChromeVirtualKeyboardDelegate() {}
 void ChromeVirtualKeyboardDelegate::GetKeyboardConfig(
     OnKeyboardSettingsCallback on_settings_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  media::AudioSystem::Get()->HasInputDevices(
+  if (!audio_system_)
+    audio_system_ = media::AudioSystem::CreateInstance();
+  audio_system_->HasInputDevices(
       base::BindOnce(&ChromeVirtualKeyboardDelegate::OnHasInputDevices,
                      weak_this_, std::move(on_settings_callback)));
 }
 
+void ChromeVirtualKeyboardDelegate::OnKeyboardConfigChanged() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  GetKeyboardConfig(base::Bind(
+      &ChromeVirtualKeyboardDelegate::DispatchConfigChangeEvent, weak_this_));
+}
+
 bool ChromeVirtualKeyboardDelegate::HideKeyboard() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   keyboard::KeyboardController* controller =
@@ -111,17 +122,6 @@ void ChromeVirtualKeyboardDelegate::SetHotrodKeyboard(bool enable) {
     ash::Shell::Get()->CreateKeyboard();
 }
 
-void ChromeVirtualKeyboardDelegate::SetKeyboardRestricted(bool restricted) {
-  if (keyboard::GetKeyboardRestricted() == restricted)
-    return;
-
-  keyboard::SetKeyboardRestricted(restricted);
-
-  // Force virtual keyboard reload.
-  if (keyboard::IsKeyboardEnabled())
-    ash::Shell::Get()->CreateKeyboard();
-}
-
 bool ChromeVirtualKeyboardDelegate::LockKeyboard(bool state) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   keyboard::KeyboardController* controller =
@@ -182,7 +182,7 @@ bool ChromeVirtualKeyboardDelegate::IsLanguageSettingsEnabled() {
 
 void ChromeVirtualKeyboardDelegate::OnHasInputDevices(
     OnKeyboardSettingsCallback on_settings_callback,
-    bool has_input_devices) {
+    bool has_audio_input_devices) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::unique_ptr<base::DictionaryValue> results(new base::DictionaryValue());
   results->SetString("layout", keyboard::GetKeyboardLayout());
@@ -191,6 +191,7 @@ void ChromeVirtualKeyboardDelegate::OnHasInputDevices(
   results->SetBoolean("a11ymode", keyboard::GetAccessibilityKeyboardEnabled());
   results->SetBoolean("hotrodmode", keyboard::GetHotrodKeyboardEnabled());
   std::unique_ptr<base::ListValue> features(new base::ListValue());
+
   features->AppendString(GenerateFeatureFlag(
       "floatingvirtualkeyboard", keyboard::IsFloatingVirtualKeyboardEnabled()));
   features->AppendString(
@@ -198,11 +199,92 @@ void ChromeVirtualKeyboardDelegate::OnHasInputDevices(
   features->AppendString(GenerateFeatureFlag(
       "gestureediting", keyboard::IsGestureEditingEnabled()));
   features->AppendString(GenerateFeatureFlag(
-      "voiceinput", has_input_devices && keyboard::IsVoiceInputEnabled()));
-  features->AppendString(GenerateFeatureFlag(
       "experimental", keyboard::IsExperimentalInputViewEnabled()));
+
+  const keyboard::KeyboardConfig config = keyboard::GetKeyboardConfig();
+  // TODO(oka): Change this to use config.voice_input.
+  features->AppendString(GenerateFeatureFlag(
+      "voiceinput", has_audio_input_devices && config.voice_input &&
+                        !base::CommandLine::ForCurrentProcess()->HasSwitch(
+                            keyboard::switches::kDisableVoiceInput)));
+  features->AppendString(
+      GenerateFeatureFlag("autocomplete", config.auto_complete));
+  features->AppendString(
+      GenerateFeatureFlag("autocorrect", config.auto_correct));
+  features->AppendString(GenerateFeatureFlag("spellcheck", config.spell_check));
+  features->AppendString(
+      GenerateFeatureFlag("handwriting", config.handwriting));
+
   results->Set("features", std::move(features));
+
   std::move(on_settings_callback).Run(std::move(results));
 }
 
+void ChromeVirtualKeyboardDelegate::DispatchConfigChangeEvent(
+    std::unique_ptr<base::DictionaryValue> settings) {
+  EventRouter* router = EventRouter::Get(browser_context_);
+
+  if (!router->HasEventListener(
+          keyboard_api::OnKeyboardConfigChanged::kEventName))
+    return;
+
+  auto event_args = std::make_unique<base::ListValue>();
+  event_args->Append(std::move(settings));
+
+  auto event = std::make_unique<extensions::Event>(
+      extensions::events::VIRTUAL_KEYBOARD_PRIVATE_ON_KEYBOARD_CONFIG_CHANGED,
+      keyboard_api::OnKeyboardConfigChanged::kEventName, std::move(event_args),
+      browser_context_);
+  router->BroadcastEvent(std::move(event));
+}
+
+api::virtual_keyboard::FeatureRestrictions
+ChromeVirtualKeyboardDelegate::RestrictFeatures(
+    const api::virtual_keyboard::RestrictFeatures::Params& params) {
+  const api::virtual_keyboard::FeatureRestrictions& restrictions =
+      params.restrictions;
+  api::virtual_keyboard::FeatureRestrictions update;
+  keyboard::KeyboardConfig config = keyboard::GetKeyboardConfig();
+  if (restrictions.spell_check_enabled &&
+      config.spell_check != *restrictions.spell_check_enabled) {
+    update.spell_check_enabled =
+        std::make_unique<bool>(*restrictions.spell_check_enabled);
+    config.spell_check = *restrictions.spell_check_enabled;
+  }
+  if (restrictions.auto_complete_enabled &&
+      config.auto_complete != *restrictions.auto_complete_enabled) {
+    update.auto_complete_enabled =
+        std::make_unique<bool>(*restrictions.auto_complete_enabled);
+    config.auto_complete = *restrictions.auto_complete_enabled;
+  }
+  if (restrictions.auto_correct_enabled &&
+      config.auto_correct != *restrictions.auto_correct_enabled) {
+    update.auto_correct_enabled =
+        std::make_unique<bool>(*restrictions.auto_correct_enabled);
+    config.auto_correct = *restrictions.auto_correct_enabled;
+  }
+  if (restrictions.voice_input_enabled &&
+      config.voice_input != *restrictions.voice_input_enabled) {
+    update.voice_input_enabled =
+        std::make_unique<bool>(*restrictions.voice_input_enabled);
+    config.voice_input = *restrictions.voice_input_enabled;
+  }
+  if (restrictions.handwriting_enabled &&
+      config.handwriting != *restrictions.handwriting_enabled) {
+    update.handwriting_enabled =
+        std::make_unique<bool>(*restrictions.handwriting_enabled);
+    config.handwriting = *restrictions.handwriting_enabled;
+  }
+
+  if (keyboard::UpdateKeyboardConfig(config)) {
+    // This reloads virtual keyboard even if it exists. This ensures virtual
+    // keyboard gets the correct state through
+    // chrome.virtualKeyboardPrivate.getKeyboardConfig.
+    // TODO(oka): Extension should reload on it's own by receiving event
+    if (keyboard::IsKeyboardEnabled())
+      ash::Shell::Get()->CreateKeyboard();
+  }
+  return update;
+}
+
 }  // namespace extensions
diff --git a/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.h b/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.h
index ac03deb8e87..562d77c5317 100644
--- a/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.h
+++ b/chromium/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.h
@@ -10,22 +10,32 @@
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/virtual_keyboard_private/virtual_keyboard_delegate.h"
+#include "extensions/common/api/virtual_keyboard.h"
+
+namespace media {
+class AudioSystem;
+}
 
 namespace extensions {
 
 class ChromeVirtualKeyboardDelegate : public VirtualKeyboardDelegate {
  public:
-  ChromeVirtualKeyboardDelegate();
+  explicit ChromeVirtualKeyboardDelegate(
+      content::BrowserContext* browser_context);
   ~ChromeVirtualKeyboardDelegate() override;
 
+  // TODO(oka): Create ChromeVirtualKeyboardPrivateDelegate class and move all
+  // the methods except for RestrictFeatures into the class for clear separation
+  // of virtualKeyboard and virtualKeyboardPrivate API.
   void GetKeyboardConfig(
       OnKeyboardSettingsCallback on_settings_callback) override;
+  void OnKeyboardConfigChanged() override;
   bool HideKeyboard() override;
   bool InsertText(const base::string16& text) override;
   bool OnKeyboardLoaded() override;
   void SetHotrodKeyboard(bool enable) override;
-  void SetKeyboardRestricted(bool restricted) override;
   bool LockKeyboard(bool state) override;
   bool SendKeyEvent(const std::string& type,
                     int char_value,
@@ -37,10 +47,17 @@ class ChromeVirtualKeyboardDelegate : public VirtualKeyboardDelegate {
   bool SetVirtualKeyboardMode(int mode_enum) override;
   bool SetRequestedKeyboardState(int state_enum) override;
 
+  api::virtual_keyboard::FeatureRestrictions RestrictFeatures(
+      const api::virtual_keyboard::RestrictFeatures::Params& params) override;
+
  private:
   void OnHasInputDevices(OnKeyboardSettingsCallback on_settings_callback,
-                         bool has_input_devices);
+                         bool has_audio_input_devices);
+  void DispatchConfigChangeEvent(
+      std::unique_ptr<base::DictionaryValue> settings);
 
+  content::BrowserContext* browser_context_;
+  std::unique_ptr<media::AudioSystem> audio_system_;
   base::WeakPtr<ChromeVirtualKeyboardDelegate> weak_this_;
   base::WeakPtrFactory<ChromeVirtualKeyboardDelegate> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(ChromeVirtualKeyboardDelegate);
diff --git a/chromium/chrome/browser/extensions/api/vpn_provider/vpn_provider_apitest.cc b/chromium/chrome/browser/extensions/api/vpn_provider/vpn_provider_apitest.cc
index daa35716969..43798f375e0 100644
--- a/chromium/chrome/browser/extensions/api/vpn_provider/vpn_provider_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/vpn_provider/vpn_provider_apitest.cc
@@ -447,8 +447,8 @@ IN_PROC_BROWSER_TEST_F(VpnProviderApiTest, CreateDisable) {
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile())->extension_service();
-  extension_service->DisableExtension(extension_id_,
-                                      extensions::disable_reason::DISABLE_NONE);
+  extension_service->DisableExtension(
+      extension_id_, extensions::disable_reason::DISABLE_USER_ACTION);
   content::RunAllPendingInMessageLoop();
   EXPECT_FALSE(DoesConfigExist(kTestConfig));
   EXPECT_FALSE(DBusThreadManager::Get()
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 861f18cfafd..49e60147206 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
@@ -575,12 +575,12 @@ void WebNavigationAPI::Shutdown() {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<WebNavigationAPI>>::
-    DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
+    DestructorAtExit g_web_navigation_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<WebNavigationAPI>*
 WebNavigationAPI::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_web_navigation_api_factory.Pointer();
 }
 
 void WebNavigationAPI::OnListenerAdded(const EventListenerInfo& details) {
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 a417fc2d61e..16c58cb39a6 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
@@ -384,17 +384,14 @@ class WebNavigationApiTest : public ExtensionApiTest {
 };
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, Api) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/api")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, GetFrame) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/getFrame")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ClientRedirect) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/clientRedirect"))
       << message_;
 }
@@ -457,50 +454,42 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ServerRedirectSingleProcess) {
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ForwardBack) {
   if (content::IsBrowserSideNavigationEnabled())
     return; // TODO(jam): investigate
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/forwardBack")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, IFrame) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/iframe")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, SrcDoc) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/srcdoc")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, OpenTab) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/openTab")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, ReferenceFragment) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/referenceFragment"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, SimpleLoad) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/simpleLoad")) << message_;
 }
 
-// Flaky on Windows and Mac. See http://crbug.com/477480 (Windows) and
-// https://crbug.com/746407 (Mac).
-#if defined(OS_WIN) || defined(OS_MACOSX)
+// Flaky on Windows, Mac and Linux. See http://crbug.com/477480 (Windows) and
+// https://crbug.com/746407 (Mac, Linux).
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
 #define MAYBE_Failures DISABLED_Failures
 #else
 #define MAYBE_Failures Failures
 #endif
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_Failures) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/failures")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, FilteredTest) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/filtered")) << message_;
 }
 
@@ -552,7 +541,6 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, MAYBE_UserAction) {
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, RequestOpenTab) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
 
   // Wait for the extension to set itself up and return control to us.
   ASSERT_TRUE(RunExtensionTest("webnavigation/requestOpenTab"))
@@ -648,7 +636,6 @@ IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, TargetBlankIncognito) {
 }
 
 IN_PROC_BROWSER_TEST_F(WebNavigationApiTest, History) {
-  ASSERT_TRUE(StartEmbeddedTestServer());
   ASSERT_TRUE(RunExtensionTest("webnavigation/history")) << message_;
 }
 
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 6e29c8b0812..d57c4155043 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
@@ -7,12 +7,12 @@
 
 #include <map>
 #include <memory>
-#include <queue>
 #include <tuple>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/containers/queue.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
@@ -173,7 +173,7 @@ class TestIPCSender : public IPC::Sender {
     return true;
   }
 
-  std::queue<base::Closure> task_queue_;
+  base::queue<base::Closure> task_queue_;
   SentMessages sent_messages_;
 };
 
@@ -601,7 +601,7 @@ TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) {
   std::unique_ptr<const base::Value> form_data =
       base::JSONReader::Read(kFormData);
   ASSERT_TRUE(form_data.get() != NULL);
-  ASSERT_TRUE(form_data->GetType() == base::Value::Type::DICTIONARY);
+  ASSERT_TRUE(form_data->type() == base::Value::Type::DICTIONARY);
   // Contents of raw.
   base::ListValue raw;
   extensions::subtle::AppendKeyValuePair(
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 873abeb4a92..2c1e20b131a 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
@@ -1102,6 +1102,51 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest,
   }
 }
 
+// Test that initiator is only included as part of event details when the
+// extension has a permission matching the initiator.
+IN_PROC_BROWSER_TEST_F(ExtensionWebRequestApiTest, MinimumAccessInitiator) {
+  ASSERT_TRUE(StartEmbeddedTestServer());
+
+  ExtensionTestMessageListener listener("ready", false);
+  const Extension* extension = LoadExtension(
+      test_data_dir_.AppendASCII("webrequest_permissions/initiator"));
+  ASSERT_TRUE(extension) << message_;
+  EXPECT_TRUE(listener.WaitUntilSatisfied());
+
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  ASSERT_TRUE(web_contents);
+
+  struct TestCase {
+    std::string navigate_before_start;
+    std::string xhr_domain;
+    std::string expected_initiator;
+  } testcases[] = {{"example.com", "example.com", "example.com"},
+                   {"example2.com", "example3.com", "example2.com"},
+                   {"no-permission.com", "example4.com", ""}};
+
+  int port = embedded_test_server()->port();
+  for (const auto& testcase : testcases) {
+    SCOPED_TRACE(testcase.navigate_before_start + ":" + testcase.xhr_domain +
+                 ":" + testcase.expected_initiator);
+    ExtensionTestMessageListener initiator_listener(false);
+    initiator_listener.set_extension_id(extension->id());
+    ui_test_utils::NavigateToURL(browser(), embedded_test_server()->GetURL(
+                                                testcase.navigate_before_start,
+                                                "/extensions/body1.html"));
+    PerformXhrInFrame(web_contents->GetMainFrame(), testcase.xhr_domain, port,
+                      "extensions/api_test/webrequest/xhr/data.json");
+    EXPECT_TRUE(initiator_listener.WaitUntilSatisfied());
+    if (testcase.expected_initiator.empty()) {
+      ASSERT_EQ("NO_INITIATOR", initiator_listener.message());
+    } else {
+      ASSERT_EQ(
+          "http://" + testcase.expected_initiator + ":" + std::to_string(port),
+          initiator_listener.message());
+    }
+  }
+}
+
 // Tests that the webRequest events aren't dispatched when the request initiator
 // is protected by policy.
 IN_PROC_BROWSER_TEST_F(ExtensionApiTestWithManagementPolicy,
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 b68ccc592b8..266fbe8f17d 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
@@ -97,7 +97,7 @@ TEST(WebRequestEventDetailsTest, SetResponseHeaders) {
     WebRequestEventDetails details(request.get(), kFilter);
     details.SetResponseHeaders(request.get(), headers.get());
     std::unique_ptr<base::DictionaryValue> dict =
-        details.GetFilteredDict(kFilter);
+        details.GetFilteredDict(kFilter, nullptr, std::string(), false);
     base::Value* filtered_headers = dict->FindPath({"responseHeaders"});
     ASSERT_TRUE(filtered_headers);
     EXPECT_EQ(2u, filtered_headers->GetList().size());
@@ -119,7 +119,7 @@ TEST(WebRequestEventDetailsTest, SetResponseHeaders) {
     WebRequestEventDetails gaia_details(gaia_request.get(), kFilter);
     gaia_details.SetResponseHeaders(gaia_request.get(), headers.get());
     std::unique_ptr<base::DictionaryValue> dict =
-        gaia_details.GetFilteredDict(kFilter);
+        gaia_details.GetFilteredDict(kFilter, nullptr, std::string(), false);
     base::Value* filtered_headers = dict->FindPath({"responseHeaders"});
     ASSERT_TRUE(filtered_headers);
     EXPECT_EQ(1u, filtered_headers->GetList().size());
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 0303a492e24..9c182d76c61 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
@@ -165,7 +165,6 @@ TEST_F(ExtensionWebRequestHelpersTestWithThreadsTest, TestHideRequestForURL) {
         sensitive_request.get(), content::RESOURCE_TYPE_SCRIPT, NULL,
         process_id, view_id, MSG_ROUTING_NONE,
         /*is_main_frame=*/false,
-        /*parent_is_main_frame=*/false,
         /*allow_download=*/true,
         /*is_async=*/false, content::PREVIEWS_OFF);
     extension_info_map_->RegisterExtensionProcess(extensions::kWebStoreAppId,
diff --git a/chromium/chrome/browser/extensions/api/web_view/chrome_web_view_internal_api.cc b/chromium/chrome/browser/extensions/api/web_view/chrome_web_view_internal_api.cc
index a3f56b999e1..11110d1fd9e 100644
--- a/chromium/chrome/browser/extensions/api/web_view/chrome_web_view_internal_api.cc
+++ b/chromium/chrome/browser/extensions/api/web_view/chrome_web_view_internal_api.cc
@@ -4,10 +4,13 @@
 
 #include "chrome/browser/extensions/api/web_view/chrome_web_view_internal_api.h"
 
+#include <memory>
+
 #include "chrome/browser/extensions/api/context_menus/context_menus_api.h"
 #include "chrome/browser/extensions/api/context_menus/context_menus_api_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/chrome_web_view_internal.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/common/error_utils.h"
 
@@ -27,7 +30,7 @@ bool ChromeWebViewInternalContextMenusCreateFunction::RunAsync() {
       Profile::FromBrowserContext(browser_context())->IsOffTheRecord(),
       MenuItem::ExtensionKey(
           extension_id(),
-          GetSenderWebContents()->GetRenderProcessHost()->GetID(),
+          GetSenderWebContents()->GetMainFrame()->GetProcess()->GetID(),
           params->instance_id));
 
   if (params->create_properties.id.get()) {
@@ -61,7 +64,7 @@ bool ChromeWebViewInternalContextMenusUpdateFunction::RunAsync() {
       profile->IsOffTheRecord(),
       MenuItem::ExtensionKey(
           extension_id(),
-          GetSenderWebContents()->GetRenderProcessHost()->GetID(),
+          GetSenderWebContents()->GetMainFrame()->GetProcess()->GetID(),
           params->instance_id));
 
   if (params->id.as_string)
@@ -89,7 +92,7 @@ bool ChromeWebViewInternalContextMenusRemoveFunction::RunAsync() {
       Profile::FromBrowserContext(browser_context())->IsOffTheRecord(),
       MenuItem::ExtensionKey(
           extension_id(),
-          GetSenderWebContents()->GetRenderProcessHost()->GetID(),
+          GetSenderWebContents()->GetMainFrame()->GetProcess()->GetID(),
           params->instance_id));
 
   if (params->menu_item_id.as_string) {
@@ -125,7 +128,7 @@ bool ChromeWebViewInternalContextMenusRemoveAllFunction::RunAsync() {
       MenuManager::Get(Profile::FromBrowserContext(browser_context()));
   menu_manager->RemoveAllContextItems(MenuItem::ExtensionKey(
       extension_id(),
-      GetSenderWebContents()->GetRenderProcessHost()->GetID(),
+      GetSenderWebContents()->GetMainFrame()->GetProcess()->GetID(),
       params->instance_id));
 
   SendResponse(true);
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 c87e15d2688..4ae4e0aea8d 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
@@ -17,6 +17,7 @@
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/media_device_id.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
@@ -34,8 +35,8 @@ namespace wap = api::webrtc_audio_private;
 using api::webrtc_audio_private::RequestInfo;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<
-    WebrtcAudioPrivateEventService>>::DestructorAtExit g_factory =
-    LAZY_INSTANCE_INITIALIZER;
+    WebrtcAudioPrivateEventService>>::DestructorAtExit
+    g_webrtc_audio_private_api_factory = LAZY_INSTANCE_INITIALIZER;
 
 WebrtcAudioPrivateEventService::WebrtcAudioPrivateEventService(
     content::BrowserContext* context)
@@ -59,7 +60,7 @@ void WebrtcAudioPrivateEventService::Shutdown() {
 // static
 BrowserContextKeyedAPIFactory<WebrtcAudioPrivateEventService>*
 WebrtcAudioPrivateEventService::GetFactoryInstance() {
-  return g_factory.Pointer();
+  return g_webrtc_audio_private_api_factory.Pointer();
 }
 
 // static
@@ -129,6 +130,13 @@ std::string WebrtcAudioPrivateFunction::device_id_salt() const {
   return device_id_salt_;
 }
 
+media::AudioSystem* WebrtcAudioPrivateFunction::GetAudioSystem() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!audio_system_)
+    audio_system_ = media::AudioSystem::CreateInstance();
+  return audio_system_.get();
+}
+
 // TODO(hlundin): Stolen from WebrtcLoggingPrivateFunction.
 // Consolidate and improve. http://crbug.com/710371
 content::RenderProcessHost*
@@ -163,7 +171,7 @@ WebrtcAudioPrivateFunction::GetRenderProcessHostFromRequest(
         expected_origin.spec().c_str(), security_origin.c_str());
     return nullptr;
   }
-  return contents->GetRenderProcessHost();
+  return contents->GetMainFrame()->GetProcess();
 }
 
 bool WebrtcAudioPrivateGetSinksFunction::RunAsync() {
@@ -180,7 +188,7 @@ bool WebrtcAudioPrivateGetSinksFunction::RunAsync() {
 void WebrtcAudioPrivateGetSinksFunction::
     GetOutputDeviceDescriptionsOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  media::AudioSystem::Get()->GetDeviceDescriptions(
+  GetAudioSystem()->GetDeviceDescriptions(
       false, base::BindOnce(&WebrtcAudioPrivateGetSinksFunction::
                                 ReceiveOutputDeviceDescriptionsOnIOThread,
                             this));
@@ -235,7 +243,7 @@ bool WebrtcAudioPrivateGetAssociatedSinkFunction::RunAsync() {
 void WebrtcAudioPrivateGetAssociatedSinkFunction::
     GetInputDeviceDescriptionsOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  media::AudioSystem::Get()->GetDeviceDescriptions(
+  GetAudioSystem()->GetDeviceDescriptions(
       true, base::BindOnce(&WebrtcAudioPrivateGetAssociatedSinkFunction::
                                ReceiveInputDeviceDescriptionsOnIOThread,
                            this));
@@ -264,7 +272,7 @@ void WebrtcAudioPrivateGetAssociatedSinkFunction::
     CalculateHMACOnIOThread(std::string());
     return;
   }
-  media::AudioSystem::Get()->GetAssociatedOutputDeviceID(
+  GetAudioSystem()->GetAssociatedOutputDeviceID(
       raw_source_id,
       base::BindOnce(
           &WebrtcAudioPrivateGetAssociatedSinkFunction::CalculateHMACOnIOThread,
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 201f72a68c1..4b6f481e27c 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
@@ -19,6 +19,10 @@
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "media/audio/audio_device_description.h"
 
+namespace media {
+class AudioSystem;
+}
+
 namespace extensions {
 
 // Listens for device changes and forwards as an extension event.
@@ -66,6 +70,8 @@ class WebrtcAudioPrivateFunction : public ChromeAsyncExtensionFunction {
   // |InitDeviceIDSalt()|.
   std::string device_id_salt() const;
 
+  media::AudioSystem* GetAudioSystem();
+
   // Returns the RenderProcessHost associated with the given |request|
   // authorized by the |security_origin|. Returns null if unauthorized or
   // the RPH does not exist.
@@ -75,6 +81,7 @@ class WebrtcAudioPrivateFunction : public ChromeAsyncExtensionFunction {
 
  private:
   std::string device_id_salt_;
+  std::unique_ptr<media::AudioSystem> audio_system_;
 
   DISALLOW_COPY_AND_ASSIGN(WebrtcAudioPrivateFunction);
 };
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 596f5db33e5..8eec628c2e9 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
@@ -62,7 +62,9 @@ namespace {
 void GetAudioDeviceDescriptions(bool for_input,
                                 AudioDeviceDescriptions* device_descriptions) {
   base::RunLoop run_loop;
-  media::AudioSystem::Get()->GetDeviceDescriptions(
+  std::unique_ptr<media::AudioSystem> audio_system =
+      media::AudioSystem::CreateInstance();
+  audio_system->GetDeviceDescriptions(
       for_input,
       base::BindOnce(
           [](base::Closure finished_callback, AudioDeviceDescriptions* result,
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
index f5c6b448fca..e13d805a9d0 100644
--- 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
@@ -21,6 +21,7 @@
 #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"
@@ -224,7 +225,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest, TestStartStopWebRtcEventLogging) {
 
   // Check that the file exists and is non-empty.
   content::RenderProcessHost* render_process_host =
-      left_tab->GetRenderProcessHost();
+      left_tab->GetMainFrame()->GetProcess();
   ASSERT_NE(render_process_host, nullptr);
   int render_process_id = render_process_host->GetID();
   base::FilePath full_file_name =
@@ -299,7 +300,7 @@ IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest,
   // The log has stopped automatically. Check that the file exists and is
   // non-empty.
   content::RenderProcessHost* render_process_host =
-      left_tab->GetRenderProcessHost();
+      left_tab->GetMainFrame()->GetProcess();
   ASSERT_NE(render_process_host, nullptr);
   int render_process_id = render_process_host->GetID();
   base::FilePath full_file_name =
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 58be6b75cfa..8f7c92d6353 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
@@ -16,6 +16,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
@@ -92,7 +93,7 @@ content::RenderProcessHost* WebrtcLoggingPrivateFunction::RphFromRequest(
         expected_origin.spec().c_str(), security_origin.c_str());
     return nullptr;
   }
-  return contents->GetRenderProcessHost();
+  return contents->GetMainFrame()->GetProcess();
 }
 
 scoped_refptr<WebRtcLoggingHandlerHost>
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 45f5cc3b689..6c441e18af3 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
@@ -23,6 +23,7 @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension_test_util.h"
 #include "chrome/common/features.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/gpu_data_manager.h"
@@ -154,9 +155,8 @@ class ExtensionWebstorePrivateApiTest : public ExtensionApiTest {
     // See http://crbug.com/177163 for details.
     return true;
 #else
-    GURL crx_url = GetTestServerURL(crx_file);
-    base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-        switches::kAppsGalleryUpdateURL, crx_url.spec());
+    const GURL crx_url = GetTestServerURL(crx_file);
+    extension_test_util::SetGalleryUpdateURL(crx_url);
 
     GURL page_url = GetTestServerURL(page);
     return RunPageTest(page_url.spec());
@@ -399,7 +399,7 @@ class ExtensionWebstoreGetWebGLStatusTest : public InProcessBrowserTest {
     std::unique_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
         function.get(), kEmptyArgs, browser()));
     ASSERT_TRUE(result);
-    EXPECT_EQ(base::Value::Type::STRING, result->GetType());
+    EXPECT_EQ(base::Value::Type::STRING, result->type());
     std::string webgl_status;
     EXPECT_TRUE(result->GetAsString(&webgl_status));
     EXPECT_STREQ(webgl_allowed ? kWebGLStatusAllowed : kWebGLStatusBlocked,
author	Allan Sandfeld Jensen <allan.jensen@qt.io>	2017-11-20 15:06:40 +0100
committer	Allan Sandfeld Jensen <allan.jensen@qt.io>	2017-11-22 11:48:58 +0000
commit	daa093eea7c773db06799a13bd7e4e2e2a9f8f14 (patch)
tree	96cc5e7b9194c1b29eab927730bfa419e7111c25 /chromium/chrome/browser/extensions/api
parent	be59a35641616a4cf23c4a13fa0632624b021c1b (diff)