BASELINE: Update Chromium to 65.0.3525.40

Also imports missing submodules

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

4 files changed, 184 insertions, 18 deletions

diff --git a/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc b/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc
index 9d3ecde9746..c057b5bebfb 100644
--- a/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc
+++ b/chromium/chrome/browser/extensions/api/extension_action/browser_action_apitest.cc
@@ -27,7 +27,6 @@
 #include "chrome/browser/ui/browser_navigator_params.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
@@ -799,10 +798,10 @@ IN_PROC_BROWSER_TEST_F(BrowserActionApiTest, BrowserActionWithRectangularIcon) {
 // Regression test for crbug.com/584747.
 IN_PROC_BROWSER_TEST_F(BrowserActionApiTest, BrowserActionOpenPopupOnPopup) {
   // Open a new web popup window.
-  chrome::NavigateParams params(browser(), GURL("http://www.google.com/"),
-                                ui::PAGE_TRANSITION_LINK);
+  NavigateParams params(browser(), GURL("http://www.google.com/"),
+                        ui::PAGE_TRANSITION_LINK);
   params.disposition = WindowOpenDisposition::NEW_POPUP;
-  params.window_action = chrome::NavigateParams::SHOW_WINDOW;
+  params.window_action = NavigateParams::SHOW_WINDOW;
   ui_test_utils::NavigateToURL(&params);
   Browser* popup_browser = params.browser;
   // Verify it is a popup, and it is the active window.
diff --git a/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc b/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc
index 3155fdf0b90..d2a853e242d 100644
--- a/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc
+++ b/chromium/chrome/browser/extensions/api/extension_action/browser_action_interactive_test.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "build/build_config.h"
@@ -95,7 +97,7 @@ class BrowserActionInteractiveTest : public ExtensionApiTest {
 
   // BrowserTestBase:
   void SetUpOnMainThread() override {
-    host_watcher_ = base::MakeUnique<ExtensionHostWatcher>();
+    host_watcher_ = std::make_unique<ExtensionHostWatcher>();
     ExtensionApiTest::SetUpOnMainThread();
     EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
   }
@@ -132,14 +134,16 @@ class BrowserActionInteractiveTest : public ExtensionApiTest {
   }
 
   // Open an extension popup via the chrome.browserAction.openPopup API.
-  void OpenPopupViaAPI() {
+  void OpenPopupViaAPI(bool will_reply) {
     // Setup the notification observer to wait for the popup to finish loading.
     content::WindowedNotificationObserver frame_observer(
         content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
         content::NotificationService::AllSources());
+    ExtensionTestMessageListener listener("ready", will_reply);
     // Show first popup in first window and expect it to have loaded.
     ASSERT_TRUE(RunExtensionSubtest("browser_action/open_popup",
                                     "open_popup_succeeds.html")) << message_;
+    EXPECT_TRUE(listener.WaitUntilSatisfied());
     frame_observer.Wait();
     EnsurePopupActive();
   }
@@ -203,7 +207,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest, TestOpenPopup) {
   // Setup extension message listener to wait for javascript to finish running.
   ExtensionTestMessageListener listener("ready", true);
   {
-    OpenPopupViaAPI();
+    OpenPopupViaAPI(true);
     EXPECT_TRUE(browserActionBar.HasPopup());
     browserActionBar.HidePopup();
   }
@@ -329,7 +333,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
   if (!ShouldRunPopupTest())
     return;
 
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser()->profile())->extension_service();
   ASSERT_FALSE(
@@ -346,7 +350,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
 IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest, FocusLossClosesPopup1) {
   if (!ShouldRunPopupTest())
     return;
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   ClosePopupViaFocusLoss();
 }
 
@@ -374,7 +378,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest, TabSwitchClosesPopup) {
   ASSERT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(browser()->tab_strip_model()->GetWebContentsAt(1),
             browser()->tab_strip_model()->GetActiveWebContents());
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
 
   content::WindowedNotificationObserver observer(
       extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
@@ -392,7 +396,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
     return;
 
   // First, we open a popup.
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   BrowserActionTestUtil browser_action_test_util(browser());
   EXPECT_TRUE(browser_action_test_util.HasPopup());
 
@@ -449,7 +453,7 @@ IN_PROC_BROWSER_TEST_F(BrowserActionInteractiveTest,
   if (!ShouldRunPopupTest())
     return;
 
-  OpenPopupViaAPI();
+  OpenPopupViaAPI(false);
   BrowserActionTestUtil test_util(browser());
   const gfx::NativeView view = test_util.GetPopupNativeView();
   EXPECT_NE(static_cast<gfx::NativeView>(NULL), view);
diff --git a/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc b/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc
index bf0c9186dd4..017614b8028 100644
--- a/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc
+++ b/chromium/chrome/browser/extensions/api/extension_action/extension_action_api.cc
@@ -5,12 +5,12 @@
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 
 #include <stddef.h>
+#include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -165,7 +165,7 @@ void ExtensionActionAPI::SetBrowserActionVisibility(
 
   GetExtensionPrefs()->UpdateExtensionPref(
       extension_id, kBrowserActionVisible,
-      base::MakeUnique<base::Value>(visible));
+      std::make_unique<base::Value>(visible));
   for (auto& observer : observers_)
     observer.OnExtensionActionVisibilityChanged(extension_id, visible);
 }
@@ -274,7 +274,7 @@ void ExtensionActionAPI::DispatchEventToExtension(
   if (!EventRouter::Get(context))
     return;
 
-  auto event = base::MakeUnique<Event>(histogram_value, event_name,
+  auto event = std::make_unique<Event>(histogram_value, event_name,
                                        std::move(event_args), context);
   event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
   EventRouter::Get(context)
@@ -516,19 +516,19 @@ ExtensionActionSetBadgeBackgroundColorFunction::RunExtensionAction() {
 ExtensionFunction::ResponseAction
 ExtensionActionGetTitleFunction::RunExtensionAction() {
   return RespondNow(OneArgument(
-      base::MakeUnique<base::Value>(extension_action_->GetTitle(tab_id_))));
+      std::make_unique<base::Value>(extension_action_->GetTitle(tab_id_))));
 }
 
 ExtensionFunction::ResponseAction
 ExtensionActionGetPopupFunction::RunExtensionAction() {
-  return RespondNow(OneArgument(base::MakeUnique<base::Value>(
+  return RespondNow(OneArgument(std::make_unique<base::Value>(
       extension_action_->GetPopupUrl(tab_id_).spec())));
 }
 
 ExtensionFunction::ResponseAction
 ExtensionActionGetBadgeTextFunction::RunExtensionAction() {
   return RespondNow(OneArgument(
-      base::MakeUnique<base::Value>(extension_action_->GetBadgeText(tab_id_))));
+      std::make_unique<base::Value>(extension_action_->GetBadgeText(tab_id_))));
 }
 
 ExtensionFunction::ResponseAction
diff --git a/chromium/chrome/browser/extensions/api/extension_action/extension_action_apitest.cc b/chromium/chrome/browser/extensions/api/extension_action/extension_action_apitest.cc
new file mode 100644
index 00000000000..abc8ca885cc
--- /dev/null
+++ b/chromium/chrome/browser/extensions/api/extension_action/extension_action_apitest.cc
@@ -0,0 +1,163 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <map>
+#include <string>
+
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "base/scoped_observer.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/browser/extensions/browsertest_util.h"
+#include "chrome/browser/extensions/extension_apitest.h"
+#include "chrome/browser/extensions/test_extension_dir.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "extensions/browser/state_store.h"
+#include "extensions/test/extension_test_message_listener.h"
+
+namespace extensions {
+namespace {
+
+// A helper class to track StateStore changes.
+class TestStateStoreObserver : public StateStore::TestObserver {
+ public:
+  TestStateStoreObserver(content::BrowserContext* context,
+                         const std::string& extension_id)
+      : extension_id_(extension_id), scoped_observer_(this) {
+    scoped_observer_.Add(ExtensionSystem::Get(context)->state_store());
+  }
+  ~TestStateStoreObserver() override {}
+
+  void WillSetExtensionValue(const std::string& extension_id,
+                             const std::string& key) override {
+    if (extension_id == extension_id_)
+      ++updated_values_[key];
+  }
+
+  int CountForKey(const std::string& key) const {
+    auto iter = updated_values_.find(key);
+    return iter == updated_values_.end() ? 0 : iter->second;
+  }
+
+ private:
+  std::string extension_id_;
+  std::map<std::string, int> updated_values_;
+
+  ScopedObserver<StateStore, StateStore::TestObserver> scoped_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestStateStoreObserver);
+};
+
+// A helper class to observe ExtensionActionAPI changes.
+class TestExtensionActionAPIObserver : public ExtensionActionAPI::Observer {
+ public:
+  TestExtensionActionAPIObserver(content::BrowserContext* context,
+                                 const std::string& extension_id)
+      : extension_id_(extension_id), scoped_observer_(this) {
+    scoped_observer_.Add(ExtensionActionAPI::Get(context));
+  }
+  ~TestExtensionActionAPIObserver() override {}
+
+  void OnExtensionActionUpdated(
+      ExtensionAction* extension_action,
+      content::WebContents* web_contents,
+      content::BrowserContext* browser_context) override {
+    if (extension_action->extension_id() == extension_id_) {
+      last_web_contents_ = web_contents;
+      run_loop_.QuitWhenIdle();
+    }
+  }
+
+  const content::WebContents* last_web_contents() const {
+    return last_web_contents_;
+  }
+
+  void Wait() { run_loop_.Run(); }
+
+ private:
+  content::WebContents* last_web_contents_ = nullptr;
+  std::string extension_id_;
+  base::RunLoop run_loop_;
+  ScopedObserver<ExtensionActionAPI, ExtensionActionAPI::Observer>
+      scoped_observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestExtensionActionAPIObserver);
+};
+
+}  // namespace
+
+using ExtensionActionAPITest = ExtensionApiTest;
+
+// Check that updating the browser action badge for a specific tab id does not
+// cause a disk write (since we only persist the defaults).
+IN_PROC_BROWSER_TEST_F(ExtensionActionAPITest, TestNoUnnecessaryIO) {
+  ExtensionTestMessageListener ready_listener("ready", false);
+
+  TestExtensionDir test_dir;
+  test_dir.WriteManifest(
+      R"({
+           "name": "Extension",
+           "description": "An extension",
+           "manifest_version": 2,
+           "version": "0.1",
+           "browser_action": {},
+           "background": { "scripts": ["background.js"] }
+         })");
+  test_dir.WriteFile(FILE_PATH_LITERAL("background.js"),
+                     "chrome.test.sendMessage('ready');");
+
+  const Extension* extension = LoadExtension(test_dir.UnpackedPath());
+  ASSERT_TRUE(extension);
+  ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
+
+  // The script template to update the browser action.
+  constexpr char kUpdate[] =
+      R"(chrome.browserAction.setBadgeText(%s);
+         domAutomationController.send('pass');)";
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  int tab_id = SessionTabHelper::IdForTab(web_contents);
+  constexpr char kBrowserActionKey[] = "browser_action";
+  TestStateStoreObserver test_state_store_observer(profile(), extension->id());
+
+  {
+    TestExtensionActionAPIObserver test_api_observer(profile(),
+                                                     extension->id());
+    // First, update a specific tab.
+    std::string update_options =
+        base::StringPrintf("{text: 'New Text', tabId: %d}", tab_id);
+    EXPECT_EQ("pass", browsertest_util::ExecuteScriptInBackgroundPage(
+                          profile(), extension->id(),
+                          base::StringPrintf(kUpdate, update_options.c_str())));
+    test_api_observer.Wait();
+
+    // The action update should be associated with the specific tab.
+    EXPECT_EQ(web_contents, test_api_observer.last_web_contents());
+    // Since this was only updating a specific tab, this should *not* result in
+    // a StateStore write. We should only write to the StateStore with new
+    // default values.
+    EXPECT_EQ(0, test_state_store_observer.CountForKey(kBrowserActionKey));
+  }
+
+  {
+    TestExtensionActionAPIObserver test_api_observer(profile(),
+                                                     extension->id());
+    // Next, update the default badge text.
+    EXPECT_EQ("pass",
+              browsertest_util::ExecuteScriptInBackgroundPage(
+                  profile(), extension->id(),
+                  base::StringPrintf(kUpdate, "{text: 'Default Text'}")));
+    test_api_observer.Wait();
+    // The action update should not be associated with a specific tab.
+    EXPECT_EQ(nullptr, test_api_observer.last_web_contents());
+
+    // This *should* result in a StateStore write, since we persist the default
+    // state of the extension action.
+    EXPECT_EQ(1, test_state_store_observer.CountForKey(kBrowserActionKey));
+  }
+}
+
+}  // namespace extensions