Some linked_ptr -> unique_ptr conversion in extensions/browser.

chrome/browser/extensions/external_provider_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/external_provider_impl.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_process_platform_part.h"
@@ skipping 497 matching lines @@
   external_loader = new ExternalPolicyLoader(
       ExtensionManagementFactory::GetForBrowserContext(profile),
       ExternalPolicyLoader::FORCED);
   external_recommended_loader = new ExternalPolicyLoader(
       ExtensionManagementFactory::GetForBrowserContext(profile),
       ExternalPolicyLoader::RECOMMENDED);
 #endif
 
   // Policies are mandatory so they can't be skipped with command line flag.
   if (external_loader.get()) {
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(
-            new ExternalProviderImpl(
-                service,
-                external_loader,
-                profile,
-                crx_location,
-                Manifest::EXTERNAL_POLICY_DOWNLOAD,
-                Extension::NO_FLAGS)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service, external_loader, profile, crx_location,
+        Manifest::EXTERNAL_POLICY_DOWNLOAD, Extension::NO_FLAGS));
   }
 
   // Load the KioskAppExternalProvider when running in kiosk mode.
   if (chrome::IsRunningInForcedAppMode()) {
 #if defined(OS_CHROMEOS)
     chromeos::KioskAppManager* kiosk_app_manager =
         chromeos::KioskAppManager::Get();
     CHECK(kiosk_app_manager);
 
     // Kiosk primary app external provider.
     if (!kiosk_app_manager->external_loader_created()) {
       // For enterprise managed kiosk apps, change the location to
       // "force-installed by policy".
       policy::BrowserPolicyConnectorChromeOS* const connector =
           g_browser_process->platform_part()
               ->browser_policy_connector_chromeos();
       Manifest::Location location = Manifest::EXTERNAL_PREF;
       if (connector && connector->IsEnterpriseManaged())
         location = Manifest::EXTERNAL_POLICY;
 
       std::unique_ptr<ExternalProviderImpl> kiosk_app_provider(
           new ExternalProviderImpl(
               service, kiosk_app_manager->CreateExternalLoader(), profile,
               location, Manifest::INVALID_LOCATION, Extension::NO_FLAGS));
       kiosk_app_provider->set_auto_acknowledge(true);
       kiosk_app_provider->set_install_immediately(true);
-      provider_list->push_back(
-          linked_ptr<ExternalProviderInterface>(kiosk_app_provider.release()));
+      provider_list->push_back(std::move(kiosk_app_provider));
     }
 
     // Kiosk secondary app external provider.
     if (!kiosk_app_manager->secondary_app_external_loader_created()) {
       std::unique_ptr<ExternalProviderImpl> secondary_kiosk_app_provider(
           new ExternalProviderImpl(
               service, kiosk_app_manager->CreateSecondaryAppExternalLoader(),
               profile, Manifest::EXTERNAL_PREF,
               Manifest::EXTERNAL_PREF_DOWNLOAD, Extension::NO_FLAGS));
       secondary_kiosk_app_provider->set_auto_acknowledge(true);
       secondary_kiosk_app_provider->set_install_immediately(true);
-      provider_list->push_back(linked_ptr<ExternalProviderInterface>(
-          secondary_kiosk_app_provider.release()));
+      provider_list->push_back(std::move(secondary_kiosk_app_provider));
     }
 #endif
     return;
   }
 
   // Extensions provided by recommended policies.
   if (external_recommended_loader.get()) {
-    provider_list->push_back(linked_ptr<ExternalProviderInterface>(
-        new ExternalProviderImpl(service,
-                                 external_recommended_loader,
-                                 profile,
-                                 crx_location,
-                                 Manifest::EXTERNAL_PREF_DOWNLOAD,
-                                 Extension::NO_FLAGS)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service, external_recommended_loader, profile, crx_location,
+        Manifest::EXTERNAL_PREF_DOWNLOAD, Extension::NO_FLAGS));
   }
 
   // In tests don't install extensions from default external sources.
   // It would only slowdown tests and make them flaky.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableDefaultApps))
     return;
 
   // On Mac OS, items in /Library/... should be written by the superuser.
   // Check that all components of the path are writable by root only.
@@ skipping 13 matching lines @@
       Extension::WAS_INSTALLED_BY_DEFAULT;
 
   if (!is_chrome_os_public_session) {
     int external_apps_path_id = profile->IsSupervised() ?
         chrome::DIR_SUPERVISED_USERS_DEFAULT_APPS :
         chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS;
     ExternalPrefLoader::Options pref_load_flags =
         profile->IsNewProfile()
             ? ExternalPrefLoader::DELAY_LOAD_UNTIL_PRIORITY_SYNC
             : ExternalPrefLoader::NONE;
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(new ExternalProviderImpl(
-            service, new ExternalPrefLoader(external_apps_path_id,
-                                            pref_load_flags, profile),
-            profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
-            bundled_extension_creation_flags)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service,
+        new ExternalPrefLoader(external_apps_path_id, pref_load_flags, profile),
+        profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
+        bundled_extension_creation_flags));
 
     // OEM default apps.
     int oem_extension_creation_flags =
         bundled_extension_creation_flags | Extension::WAS_INSTALLED_BY_OEM;
     chromeos::ServicesCustomizationDocument* customization =
         chromeos::ServicesCustomizationDocument::GetInstance();
-    provider_list->push_back(linked_ptr<ExternalProviderInterface>(
-        new ExternalProviderImpl(service,
-                                 customization->CreateExternalLoader(profile),
-                                 profile,
-                                 Manifest::EXTERNAL_PREF,
-                                 Manifest::EXTERNAL_PREF_DOWNLOAD,
-                                 oem_extension_creation_flags)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service, customization->CreateExternalLoader(profile), profile,
+        Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
+        oem_extension_creation_flags));
   }
 #elif defined(OS_LINUX)
   if (!profile->IsLegacySupervised()) {
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(
-            new ExternalProviderImpl(
-                service,
-                new ExternalPrefLoader(
-                    chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS,
-                    ExternalPrefLoader::NONE,
-                    NULL),
-                profile,
-                Manifest::EXTERNAL_PREF,
-                Manifest::EXTERNAL_PREF_DOWNLOAD,
-                bundled_extension_creation_flags)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service,
+        new ExternalPrefLoader(chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS,
+                               ExternalPrefLoader::NONE, nullptr),
+        profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
+        bundled_extension_creation_flags));
   }
 #endif
 
   if (!profile->IsLegacySupervised()) {
 #if defined(OS_WIN)
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(
-            new ExternalProviderImpl(
-                service,
-                new ExternalRegistryLoader,
-                profile,
-                Manifest::EXTERNAL_REGISTRY,
-                Manifest::EXTERNAL_PREF_DOWNLOAD,
-                Extension::NO_FLAGS)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service, new ExternalRegistryLoader, profile,
+        Manifest::EXTERNAL_REGISTRY, Manifest::EXTERNAL_PREF_DOWNLOAD,
+        Extension::NO_FLAGS));
 #else
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(
-            new ExternalProviderImpl(
-                service,
-                new ExternalPrefLoader(chrome::DIR_EXTERNAL_EXTENSIONS,
-                                       check_admin_permissions_on_mac,
-                                       NULL),
-                profile,
-                Manifest::EXTERNAL_PREF,
-                Manifest::EXTERNAL_PREF_DOWNLOAD,
-                bundled_extension_creation_flags)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service,
+        new ExternalPrefLoader(chrome::DIR_EXTERNAL_EXTENSIONS,
+                               check_admin_permissions_on_mac, nullptr),
+        profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
+        bundled_extension_creation_flags));
 
     // Define a per-user source of external extensions.
 #if defined(OS_MACOSX) || (defined(OS_LINUX) && defined(CHROMIUM_BUILD))
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(
-            new ExternalProviderImpl(
-                service,
-                new ExternalPrefLoader(chrome::DIR_USER_EXTERNAL_EXTENSIONS,
-                                       ExternalPrefLoader::NONE,
-                                       NULL),
-                profile,
-                Manifest::EXTERNAL_PREF,
-                Manifest::EXTERNAL_PREF_DOWNLOAD,
-                Extension::NO_FLAGS)));
+    provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+        service, new ExternalPrefLoader(chrome::DIR_USER_EXTERNAL_EXTENSIONS,
+                                        ExternalPrefLoader::NONE, nullptr),
+        profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
+        Extension::NO_FLAGS));
 #endif
 #endif
 
 #if !defined(OS_CHROMEOS)
     // The default apps are installed as INTERNAL but use the external
     // extension installer codeflow.
-    provider_list->push_back(
-        linked_ptr<ExternalProviderInterface>(
-            new default_apps::Provider(
-                profile,
-                service,
-                new ExternalPrefLoader(chrome::DIR_DEFAULT_APPS,
-                                       ExternalPrefLoader::NONE,
-                                       NULL),
-                Manifest::INTERNAL,
-                Manifest::INTERNAL,
-                Extension::FROM_WEBSTORE |
-                    Extension::WAS_INSTALLED_BY_DEFAULT)));
+    provider_list->push_back(base::MakeUnique<default_apps::Provider>(
+        profile, service,
+        new ExternalPrefLoader(chrome::DIR_DEFAULT_APPS,
+                               ExternalPrefLoader::NONE, nullptr),
+        Manifest::INTERNAL, Manifest::INTERNAL,
+        Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT));
 #endif
 
     std::unique_ptr<ExternalProviderImpl> drive_migration_provider(
         new ExternalProviderImpl(
             service,
             new ExtensionMigrator(profile, extension_misc::kDriveHostedAppId,
                                   extension_misc::kDriveExtensionId),
             profile, Manifest::EXTERNAL_PREF, Manifest::EXTERNAL_PREF_DOWNLOAD,
             Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT));
     drive_migration_provider->set_auto_acknowledge(true);
-    provider_list->push_back(linked_ptr<ExternalProviderInterface>(
-        drive_migration_provider.release()));
+    provider_list->push_back(std::move(drive_migration_provider));
   }
 
-  provider_list->push_back(
-    linked_ptr<ExternalProviderInterface>(
-      new ExternalProviderImpl(
-          service,
-          new ExternalComponentLoader(profile),
-          profile,
-          Manifest::INVALID_LOCATION,
-          Manifest::EXTERNAL_COMPONENT,
-          Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT)));
+  provider_list->push_back(base::MakeUnique<ExternalProviderImpl>(
+      service, new ExternalComponentLoader(profile), profile,
+      Manifest::INVALID_LOCATION, Manifest::EXTERNAL_COMPONENT,
+      Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT));
 }
 
 }  // namespace extensions