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

chrome/browser/chromeos/extensions/file_manager/private_api_misc.cc

 // Copyright 2013 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/chromeos/extensions/file_manager/private_api_misc.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 40 matching lines @@
 #include "content/public/common/page_zoom.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "google_apis/drive/auth_service.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "url/gurl.h"
 
 namespace extensions {
 namespace {
 
+using api::file_manager_private::ProfileInfo;
+
 const char kCWSScope[] = "https://www.googleapis.com/auth/chromewebstore";
 
 // Obtains the current app window.
 AppWindow* GetCurrentAppWindow(ChromeSyncExtensionFunction* function) {
   content::WebContents* const contents = function->GetSenderWebContents();
   return contents ?
       AppWindowRegistry::Get(function->GetProfile())->
           GetAppWindowForWebContents(contents) : nullptr;
 }
 
-std::vector<linked_ptr<api::file_manager_private::ProfileInfo> >
-GetLoggedInProfileInfoList() {
+std::vector<ProfileInfo> GetLoggedInProfileInfoList() {
   DCHECK(user_manager::UserManager::IsInitialized());
   const std::vector<Profile*>& profiles =
       g_browser_process->profile_manager()->GetLoadedProfiles();
   std::set<Profile*> original_profiles;
-  std::vector<linked_ptr<api::file_manager_private::ProfileInfo> >
-      result_profiles;
+  std::vector<ProfileInfo> result_profiles;
 
-  for (size_t i = 0; i < profiles.size(); ++i) {
+  for (Profile* profile : profiles) {
     // Filter the profile.
-    Profile* const profile = profiles[i]->GetOriginalProfile();
+    profile = profile->GetOriginalProfile();
     if (original_profiles.count(profile))
       continue;
     original_profiles.insert(profile);
     const user_manager::User* const user =
         chromeos::ProfileHelper::Get()->GetUserByProfile(profile);
     if (!user || !user->is_logged_in())
       continue;
 
     // Make a ProfileInfo.
-    linked_ptr<api::file_manager_private::ProfileInfo> profile_info(
-        new api::file_manager_private::ProfileInfo());
-    profile_info->profile_id =
+    ProfileInfo profile_info;
+    profile_info.profile_id =
         multi_user_util::GetAccountIdFromProfile(profile).GetUserEmail();
-    profile_info->display_name = UTF16ToUTF8(user->GetDisplayName());
+    profile_info.display_name = UTF16ToUTF8(user->GetDisplayName());
     // TODO(hirono): Remove the property from the profile_info.
-    profile_info->is_current_profile = true;
+    profile_info.is_current_profile = true;
 
-    result_profiles.push_back(profile_info);
+    result_profiles.push_back(std::move(profile_info));
   }
 
   return result_profiles;
 }
 
 // Converts a list of file system urls (as strings) to a pair of a provided file
 // system object and a list of unique paths on the file system. In case of an
 // error, false is returned and the error message set.
 bool ConvertURLsToProvidedInfo(
     const scoped_refptr<storage::FileSystemContext>& file_system_context,
@@ skipping 255 matching lines @@
       logger->Log(logging::LOG_ERROR,
                   "CWS OAuth token fetch failed. (DriveApiErrorCode: %s)",
                   google_apis::DriveApiErrorCodeToString(code).c_str());
     }
     SetResult(base::Value::CreateNullValue());
     SendResponse(false);
   }
 }
 
 bool FileManagerPrivateGetProfilesFunction::RunSync() {
-  const std::vector<linked_ptr<api::file_manager_private::ProfileInfo> >&
-      profiles = GetLoggedInProfileInfoList();
+  const std::vector<ProfileInfo>& profiles = GetLoggedInProfileInfoList();
 
   // Obtains the display profile ID.
   AppWindow* const app_window = GetCurrentAppWindow(this);
   chrome::MultiUserWindowManager* const window_manager =
       chrome::MultiUserWindowManager::GetInstance();
   const AccountId current_profile_id =
       multi_user_util::GetAccountIdFromProfile(GetProfile());
   const AccountId display_profile_id =
       window_manager && app_window
           ? window_manager->GetUserPresentingWindow(
@@ skipping 93 matching lines @@
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateGetProvidingExtensionsFunction::Run() {
   using chromeos::file_system_provider::Service;
   using chromeos::file_system_provider::ProvidingExtensionInfo;
   const Service* const service = Service::Get(chrome_details_.GetProfile());
   const std::vector<ProvidingExtensionInfo> info_list =
       service->GetProvidingExtensionInfoList();
 
   using api::file_manager_private::ProvidingExtension;
-  std::vector<linked_ptr<ProvidingExtension>> providing_extensions;
+  std::vector<ProvidingExtension> providing_extensions;
   for (const auto& info : info_list) {
-    const linked_ptr<ProvidingExtension> providing_extension(
-        new ProvidingExtension);
-    providing_extension->extension_id = info.extension_id;
-    providing_extension->name = info.name;
-    providing_extension->configurable = info.capabilities.configurable();
-    providing_extension->watchable = info.capabilities.watchable();
-    providing_extension->multiple_mounts = info.capabilities.multiple_mounts();
+    ProvidingExtension providing_extension;
+    providing_extension.extension_id = info.extension_id;
+    providing_extension.name = info.name;
+    providing_extension.configurable = info.capabilities.configurable();
+    providing_extension.watchable = info.capabilities.watchable();
+    providing_extension.multiple_mounts = info.capabilities.multiple_mounts();
     switch (info.capabilities.source()) {
       case SOURCE_FILE:
-        providing_extension->source =
+        providing_extension.source =
             api::manifest_types::FILE_SYSTEM_PROVIDER_SOURCE_FILE;
         break;
       case SOURCE_DEVICE:
-        providing_extension->source =
+        providing_extension.source =
             api::manifest_types::FILE_SYSTEM_PROVIDER_SOURCE_DEVICE;
         break;
       case SOURCE_NETWORK:
-        providing_extension->source =
+        providing_extension.source =
             api::manifest_types::FILE_SYSTEM_PROVIDER_SOURCE_NETWORK;
         break;
     }
-    providing_extensions.push_back(providing_extension);
+    providing_extensions.push_back(std::move(providing_extension));
   }
 
   return RespondNow(ArgumentList(
       api::file_manager_private::GetProvidingExtensions::Results::Create(
           providing_extensions)));
 }
 
 FileManagerPrivateAddProvidedFileSystemFunction::
     FileManagerPrivateAddProvidedFileSystemFunction()
     : chrome_details_(this) {
@@ skipping 105 matching lines @@
 
 void FileManagerPrivateInternalGetCustomActionsFunction::OnCompleted(
     const chromeos::file_system_provider::Actions& actions,
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to fetch actions."));
     return;
   }
 
   using api::file_system_provider::Action;
-  std::vector<linked_ptr<Action>> items;
+  std::vector<Action> items;
   for (const auto& action : actions) {
-    const linked_ptr<Action> item(new Action);
-    item->id = action.id;
-    item->title.reset(new std::string(action.title));
-    items.push_back(item);
+    Action item;
+    item.id = action.id;
+    item.title.reset(new std::string(action.title));
+    items.push_back(std::move(item));
   }
 
   Respond(ArgumentList(
       api::file_manager_private_internal::GetCustomActions::Results::Create(
           items)));
 }
 
 FileManagerPrivateInternalExecuteCustomActionFunction::
     FileManagerPrivateInternalExecuteCustomActionFunction()
     : chrome_details_(this) {}
@@ skipping 32 matching lines @@
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to execute the action."));
     return;
   }
 
   Respond(NoArguments());
 }
 
 }  // namespace extensions