Modernize some extensions code.

chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <deque>
 #include <memory>
 #include <set>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
+#include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_with_install.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/update_install_gate.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/event_router_factory.h"
@@ skipping 12 matching lines @@
 class TestEventRouter : public EventRouter {
  public:
   explicit TestEventRouter(content::BrowserContext* context)
       : EventRouter(context, ExtensionPrefs::Get(context)) {}
   ~TestEventRouter() override {}
 
   // An entry in our fake event registry.
   using Entry = std::pair<std::string, std::string>;
 
   bool ExtensionHasEventListener(const std::string& extension_id,
-                                 const std::string& event_name) override {
-    return fake_registry_.find(Entry(extension_id, event_name)) !=
-           fake_registry_.end();
+                                 const std::string& event_name) const override {
+    return base::ContainsKey(fake_registry_, Entry(extension_id, event_name));
   }
 
   // Pretend that |extension_id| is listening for |event_name|.
   void AddFakeListener(const std::string& extension_id,
                        const std::string& event_name) {
     fake_registry_.insert(Entry(extension_id, event_name));
   }
 
  private:
   std::set<Entry> fake_registry_;
@@ skipping 92 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DownloaderTestDelegate);
 };
 
 // Helper to let test code wait for and return an update check result.
 class UpdateCheckResultCatcher {
  public:
   UpdateCheckResultCatcher() {}
 
   void OnResult(const RuntimeAPIDelegate::UpdateCheckResult& result) {
     EXPECT_EQ(nullptr, result_.get());
-    result_.reset(new RuntimeAPIDelegate::UpdateCheckResult(
-        result.success, result.response, result.version));
+    result_ = base::MakeUnique<RuntimeAPIDelegate::UpdateCheckResult>(
+        result.success, result.response, result.version);
     if (run_loop_)
       run_loop_->Quit();
   }
 
   std::unique_ptr<RuntimeAPIDelegate::UpdateCheckResult> WaitForResult() {
     if (!result_) {
-      run_loop_.reset(new base::RunLoop);
+      run_loop_ = base::MakeUnique<base::RunLoop>();
       run_loop_->Run();
     }
     return std::move(result_);
   }
 
  private:
   std::unique_ptr<RuntimeAPIDelegate::UpdateCheckResult> result_;
   std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckResultCatcher);
 };
 
 class ChromeRuntimeAPIDelegateTest : public ExtensionServiceTestWithInstall {
  public:
   ChromeRuntimeAPIDelegateTest() {}
 
   void SetUp() override {
     ExtensionServiceTestWithInstall::SetUp();
     ExtensionDownloader::set_test_delegate(&downloader_test_delegate_);
     ChromeRuntimeAPIDelegate::set_tick_clock_for_tests(&clock_);
 
     InitializeExtensionServiceWithUpdater();
-    runtime_delegate_.reset(new ChromeRuntimeAPIDelegate(browser_context()));
+    runtime_delegate_ =
+        base::MakeUnique<ChromeRuntimeAPIDelegate>(browser_context());
     service()->updater()->SetExtensionCacheForTesting(nullptr);
     EventRouterFactory::GetInstance()->SetTestingFactory(
         browser_context(), &TestEventRouterFactoryFunction);
 
     // Setup the ExtensionService so that extension updates won't complete
     // installation until the extension is idle.
-    update_install_gate_.reset(new UpdateInstallGate(service()));
+    update_install_gate_ = base::MakeUnique<UpdateInstallGate>(service());
     service()->RegisterInstallGate(ExtensionPrefs::DELAY_REASON_WAIT_FOR_IDLE,
                                    update_install_gate_.get());
     static_cast<TestExtensionSystem*>(ExtensionSystem::Get(browser_context()))
         ->SetReady();
   }
 
   void TearDown() override {
     ExtensionDownloader::set_test_delegate(nullptr);
     ChromeRuntimeAPIDelegate::set_tick_clock_for_tests(nullptr);
     ExtensionServiceTestWithInstall::TearDown();
@@ skipping 100 matching lines @@
 
   // Call again after a longer delay, we should should be unthrottled.
   clock_.Advance(base::TimeDelta::FromHours(8));
   downloader_test_delegate_.AddNoUpdateResponse(id);
   DoUpdateCheck(id, "no_update", "");
 }
 
 }  // namespace
 
 }  // namespace extensions