Remove Profile usage from //apps

apps/saved_files_service.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/saved_files_service.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <unordered_map>
 #include <utility>
 
 #include "apps/saved_files_service_factory.h"
 #include "base/memory/ptr_util.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 namespace apps {
@@ skipping 122 matching lines @@
                                const base::FilePath& path,
                                bool is_directory,
                                int sequence_number)
     : id(id),
       path(path),
       is_directory(is_directory),
       sequence_number(sequence_number) {}
 
 class SavedFilesService::SavedFiles {
  public:
-  SavedFiles(Profile* profile, const std::string& extension_id);
+  SavedFiles(content::BrowserContext* context, const std::string& extension_id);
   ~SavedFiles();
 
   void RegisterFileEntry(const std::string& id,
                          const base::FilePath& file_path,
                          bool is_directory);
   void EnqueueFileEntry(const std::string& id);
   bool IsRegistered(const std::string& id) const;
   const SavedFileEntry* GetFileEntry(const std::string& id) const;
   std::vector<SavedFileEntry> GetAllFileEntries() const;
 
  private:
   // Compacts sequence numbers if the largest sequence number is
   // g_max_sequence_number. Outside of testing, it is set to kint32max, so this
   // will almost never do any real work.
   void MaybeCompactSequenceNumbers();
 
   void LoadSavedFileEntriesFromPreferences();
 
-  Profile* profile_;
+  content::BrowserContext* context_;
   const std::string extension_id_;
 
   // Contains all file entries that have been registered, keyed by ID.
   std::unordered_map<std::string, std::unique_ptr<SavedFileEntry>>
       registered_file_entries_;
 
   // The queue of file entries that have been retained, keyed by
   // sequence_number. Values are a subset of values in registered_file_entries_.
   // This should be kept in sync with file entries stored in extension prefs.
   std::map<int, SavedFileEntry*> saved_file_lru_;
 
   DISALLOW_COPY_AND_ASSIGN(SavedFiles);
 };
 
 // static
-SavedFilesService* SavedFilesService::Get(Profile* profile) {
-  return SavedFilesServiceFactory::GetForProfile(profile);
+SavedFilesService* SavedFilesService::Get(content::BrowserContext* context) {
+  return SavedFilesServiceFactory::GetForBrowserContext(context);
 }
 
-SavedFilesService::SavedFilesService(Profile* profile) : profile_(profile) {
+SavedFilesService::SavedFilesService(content::BrowserContext* context)
+    : context_(context) {
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 }
 
 SavedFilesService::~SavedFilesService() {}
 
@@ skipping 30 matching lines @@
 void SavedFilesService::EnqueueFileEntry(const std::string& extension_id,
                                          const std::string& id) {
   GetOrInsert(extension_id)->EnqueueFileEntry(id);
 }
 
 std::vector<SavedFileEntry> SavedFilesService::GetAllFileEntries(
     const std::string& extension_id) {
   SavedFiles* saved_files = Get(extension_id);
   if (saved_files)
     return saved_files->GetAllFileEntries();
-  return GetSavedFileEntries(ExtensionPrefs::Get(profile_), extension_id);
+  return GetSavedFileEntries(ExtensionPrefs::Get(context_), extension_id);
 }
 
 bool SavedFilesService::IsRegistered(const std::string& extension_id,
                                      const std::string& id) {
   return GetOrInsert(extension_id)->IsRegistered(id);
 }
 
 const SavedFileEntry* SavedFilesService::GetFileEntry(
     const std::string& extension_id,
     const std::string& id) {
   return GetOrInsert(extension_id)->GetFileEntry(id);
 }
 
 void SavedFilesService::ClearQueueIfNoRetainPermission(
     const Extension* extension) {
   if (!extension->permissions_data()->active_permissions().HasAPIPermission(
           APIPermission::kFileSystemRetainEntries)) {
     ClearQueue(extension);
   }
 }
 
 void SavedFilesService::ClearQueue(const extensions::Extension* extension) {
-  ClearSavedFileEntries(ExtensionPrefs::Get(profile_), extension->id());
+  ClearSavedFileEntries(ExtensionPrefs::Get(context_), extension->id());
   Clear(extension->id());
 }
 
 SavedFilesService::SavedFiles* SavedFilesService::Get(
     const std::string& extension_id) const {
   auto it = extension_id_to_saved_files_.find(extension_id);
   if (it != extension_id_to_saved_files_.end())
     return it->second.get();
 
   return NULL;
 }
 
 SavedFilesService::SavedFiles* SavedFilesService::GetOrInsert(
     const std::string& extension_id) {
   SavedFiles* saved_files = Get(extension_id);
   if (saved_files)
     return saved_files;
 
   std::unique_ptr<SavedFiles> scoped_saved_files(
-      new SavedFiles(profile_, extension_id));
+      new SavedFiles(context_, extension_id));
   saved_files = scoped_saved_files.get();
   extension_id_to_saved_files_.insert(
       std::make_pair(extension_id, std::move(scoped_saved_files)));
   return saved_files;
 }
 
 void SavedFilesService::Clear(const std::string& extension_id) {
   extension_id_to_saved_files_.erase(extension_id);
 }
 
-SavedFilesService::SavedFiles::SavedFiles(Profile* profile,
+SavedFilesService::SavedFiles::SavedFiles(content::BrowserContext* context,
                                           const std::string& extension_id)
-    : profile_(profile), extension_id_(extension_id) {
+    : context_(context), extension_id_(extension_id) {
   LoadSavedFileEntriesFromPreferences();
 }
 
 SavedFilesService::SavedFiles::~SavedFiles() {}
 
 void SavedFilesService::SavedFiles::RegisterFileEntry(
     const std::string& id,
     const base::FilePath& file_path,
     bool is_directory) {
   auto it = registered_file_entries_.find(id);
@@ skipping 17 matching lines @@
     if (it->second == file_entry)
       return;
 
     file_entry->sequence_number = it->first + 1;
   } else {
     // The first sequence number is 1, as 0 means the entry is not in the LRU.
     file_entry->sequence_number = 1;
   }
   saved_file_lru_.insert(
       std::make_pair(file_entry->sequence_number, file_entry));
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
   if (old_sequence_number) {
     saved_file_lru_.erase(old_sequence_number);
     UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
   } else {
     AddSavedFileEntry(prefs, extension_id_, *file_entry);
     if (saved_file_lru_.size() > g_max_saved_file_entries) {
       std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
       it->second->sequence_number = 0;
       RemoveSavedFileEntry(prefs, extension_id_, it->second->id);
       saved_file_lru_.erase(it);
@@ skipping 34 matching lines @@
       saved_file_lru_.rbegin();
   if (it == saved_file_lru_.rend())
     return;
 
   // Only compact sequence numbers if the last entry's sequence number is the
   // maximum value.  This should almost never be the case.
   if (it->first < g_max_sequence_number)
     return;
 
   int sequence_number = 0;
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
   for (std::map<int, SavedFileEntry*>::iterator it = saved_file_lru_.begin();
        it != saved_file_lru_.end();
        ++it) {
     sequence_number++;
     if (it->second->sequence_number == sequence_number)
       continue;
 
     SavedFileEntry* file_entry = it->second;
     file_entry->sequence_number = sequence_number;
     UpdateSavedFileEntry(prefs, extension_id_, *file_entry);
     saved_file_lru_.erase(it++);
     // Provide the following element as an insert hint. While optimized
     // insertion time with the following element as a hint is only supported by
     // the spec in C++11, the implementations do support this.
     it = saved_file_lru_.insert(
         it, std::make_pair(file_entry->sequence_number, file_entry));
   }
 }
 
 void SavedFilesService::SavedFiles::LoadSavedFileEntriesFromPreferences() {
-  ExtensionPrefs* prefs = ExtensionPrefs::Get(profile_);
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(context_);
   std::vector<SavedFileEntry> saved_entries =
       GetSavedFileEntries(prefs, extension_id_);
   for (std::vector<SavedFileEntry>::iterator it = saved_entries.begin();
        it != saved_entries.end();
        ++it) {
     std::unique_ptr<SavedFileEntry> file_entry(new SavedFileEntry(*it));
     const std::string& id = file_entry->id;
     saved_file_lru_.insert(
         std::make_pair(file_entry->sequence_number, file_entry.get()));
     registered_file_entries_[id] = std::move(file_entry);
@@ skipping 14 matching lines @@
 void SavedFilesService::SetLruSizeForTest(int size) {
   g_max_saved_file_entries = size;
 }
 
 // static
 void SavedFilesService::ClearLruSizeForTest() {
   g_max_saved_file_entries = kMaxSavedFileEntries;
 }
 
 }  // namespace apps