convert //apps to std::unique_ptr

apps/launcher.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 "apps/launcher.h"
 
+#include <memory>
 #include <set>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/api/file_handlers/directory_util.h"
 #include "chrome/browser/extensions/api/file_handlers/mime_util.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 142 matching lines @@
             base::Bind(&PlatformAppPathLauncher::LaunchWithNoLaunchData, this));
         return;
       }
     }
 
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&PlatformAppPathLauncher::Launch, this));
   }
 
-  void OnFilesValid(scoped_ptr<std::set<base::FilePath>> directory_paths) {
+  void OnFilesValid(std::unique_ptr<std::set<base::FilePath>> directory_paths) {
     mime_type_collector_.CollectForLocalPaths(
         entry_paths_,
         base::Bind(
             &PlatformAppPathLauncher::OnAreDirectoriesAndMimeTypesCollected,
             this, base::Passed(std::move(directory_paths))));
   }
 
   void OnFilesInvalid(const base::FilePath& /* error_path */) {
     LaunchWithNoLaunchData();
   }
 
   void LaunchWithNoLaunchData() {
     // This method is required as an entry point on the UI thread.
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     const Extension* extension = GetExtension();
     if (!extension)
       return;
 
     AppRuntimeEventRouter::DispatchOnLaunchedEvent(
         profile_, extension, extensions::SOURCE_FILE_HANDLER);
   }
 
   void OnAreDirectoriesCollected(
       bool has_file_system_write_permission,
-      scoped_ptr<std::set<base::FilePath>> directory_paths) {
+      std::unique_ptr<std::set<base::FilePath>> directory_paths) {
     if (has_file_system_write_permission) {
       std::set<base::FilePath>* const directory_paths_ptr =
           directory_paths.get();
       PrepareFilesForWritableApp(
           entry_paths_, profile_, *directory_paths_ptr,
           base::Bind(&PlatformAppPathLauncher::OnFilesValid, this,
                      base::Passed(std::move(directory_paths))),
           base::Bind(&PlatformAppPathLauncher::OnFilesInvalid, this));
       return;
     }
 
     OnFilesValid(std::move(directory_paths));
   }
 
   void OnAreDirectoriesAndMimeTypesCollected(
-      scoped_ptr<std::set<base::FilePath>> directory_paths,
-      scoped_ptr<std::vector<std::string>> mime_types) {
+      std::unique_ptr<std::set<base::FilePath>> directory_paths,
+      std::unique_ptr<std::vector<std::string>> mime_types) {
     DCHECK(entry_paths_.size() == mime_types->size());
     // If fetching a mime type failed, then use a fallback one.
     for (size_t i = 0; i < entry_paths_.size(); ++i) {
       const std::string mime_type =
           !(*mime_types)[i].empty() ? (*mime_types)[i] : kFallbackMimeType;
       bool is_directory =
           directory_paths->find(entry_paths_[i]) != directory_paths->end();
       entries_.push_back(
           extensions::EntryInfo(entry_paths_[i], mime_type, is_directory));
     }
@@ skipping 210 matching lines @@
 void LaunchPlatformAppWithUrl(Profile* profile,
                               const Extension* extension,
                               const std::string& handler_id,
                               const GURL& url,
                               const GURL& referrer_url) {
   AppRuntimeEventRouter::DispatchOnLaunchedEventWithUrl(
       profile, extension, handler_id, url, referrer_url);
 }
 
 }  // namespace apps