[Extensions] Convert APIs to use movable types [5]

chrome/browser/extensions/api/file_system/file_system_api.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/api/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 238 matching lines @@
 content::WebContents* GetWebContentsForAppId(Profile* profile,
                                              const std::string& app_id) {
   AppWindowRegistry* const registry = AppWindowRegistry::Get(profile);
   DCHECK(registry);
   AppWindow* const app_window = registry->GetCurrentAppWindowForApp(app_id);
   return app_window ? app_window->web_contents() : nullptr;
 }
 
 // Fills a list of volumes mounted in the system.
 void FillVolumeList(Profile* profile,
-                    std::vector<linked_ptr<api::file_system::Volume>>* result) {
-  using file_manager::VolumeManager;
-  VolumeManager* const volume_manager = VolumeManager::Get(profile);
+                    std::vector<api::file_system::Volume>* result) {
+  file_manager::VolumeManager* const volume_manager =
+      file_manager::VolumeManager::Get(profile);
   DCHECK(volume_manager);
 
-  using api::file_system::Volume;
   const auto& volume_list = volume_manager->GetVolumeList();
   // Convert volume_list to result_volume_list.
   for (const auto& volume : volume_list) {
-    const linked_ptr<Volume> result_volume(new Volume);
-    result_volume->volume_id = volume->volume_id();
-    result_volume->writable = !volume->is_read_only();
-    result->push_back(result_volume);
+    api::file_system::Volume result_volume;
+    result_volume.volume_id = volume->volume_id();
+    result_volume.writable = !volume->is_read_only();
+    result->push_back(std::move(result_volume));
   }
 }
 #endif
 
 }  // namespace
 
 namespace file_system_api {
 
 base::FilePath GetLastChooseEntryDirectory(const ExtensionPrefs* prefs,
                                            const std::string& extension_id) {
@@ skipping 690 matching lines @@
     const AcceptOptions* accepts,
     const bool* acceptsAllTypes) {
   file_type_info->include_all_files = true;
   if (acceptsAllTypes)
     file_type_info->include_all_files = *acceptsAllTypes;
 
   bool need_suggestion = !file_type_info->include_all_files &&
                          !suggested_extension.empty();
 
   if (accepts) {
-    typedef file_system::AcceptOption AcceptOption;
-    for (std::vector<linked_ptr<AcceptOption> >::const_iterator iter =
-            accepts->begin(); iter != accepts->end(); ++iter) {
+    for (const file_system::AcceptOption& option : *accepts) {
       base::string16 description;
       std::vector<base::FilePath::StringType> extensions;
 
-      if (!GetFileTypesFromAcceptOption(**iter, &extensions, &description))
+      if (!GetFileTypesFromAcceptOption(option, &extensions, &description))
         continue;  // No extensions were found.
 
       file_type_info->extensions.push_back(extensions);
       file_type_info->extension_description_overrides.push_back(description);
 
       // If we still need to find suggested_extension, hunt for it inside the
       // extensions returned from GetFileTypesFromAcceptOption.
       if (need_suggestion && std::find(extensions.begin(),
               extensions.end(), suggested_extension) != extensions.end()) {
         need_suggestion = false;
@@ skipping 442 matching lines @@
 
 ExtensionFunction::ResponseAction FileSystemGetVolumeListFunction::Run() {
   // Only kiosk apps in kiosk sessions can use this API.
   // Additionally it is enabled for whitelisted component extensions and apps.
   file_system_api::ConsentProviderDelegate consent_provider_delegate(
       chrome_details_.GetProfile(), render_frame_host());
   file_system_api::ConsentProvider consent_provider(&consent_provider_delegate);
 
   if (!consent_provider.IsGrantable(*extension()))
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
-  using api::file_system::Volume;
-  std::vector<linked_ptr<Volume>> result_volume_list;
+  std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions