.

extensions/browser/api/file_handlers/app_file_handler_util.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_handlers/app_file_handler_util.h"
+#include "extensions/browser/api/file_handlers/app_file_handler_util.h"
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "build/build_config.h"
-#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/entry_info.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/granted_file_entry.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "net/base/mime_util.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "storage/common/fileapi/file_system_mount_option.h"
@@ skipping 73 matching lines @@
 // Checks whether a list of paths are all OK for writing and calls a provided
 // on_success or on_failure callback when done. A path is OK for writing if it
 // is not a symlink, is not in a blacklisted path and can be opened for writing.
 // Creates files if they do not exist, but fails for non-existent directory
 // paths. On Chrome OS, also fails for non-local files that don't already exist.
 class WritableFileChecker
     : public base::RefCountedThreadSafe<WritableFileChecker> {
  public:
   WritableFileChecker(
       const std::vector<base::FilePath>& paths,
-      Profile* profile,
+      content::BrowserContext* context,
       const std::set<base::FilePath>& directory_paths,
       const base::Closure& on_success,
       const base::Callback<void(const base::FilePath&)>& on_failure);
 
   void Check();
 
  private:
   friend class base::RefCountedThreadSafe<WritableFileChecker>;
   virtual ~WritableFileChecker();
 
   // Called when a work item is completed. If all work items are done, this
   // calls the success or failure callback.
   void TaskDone();
 
   // Reports an error in completing a work item. This may be called more than
   // once, but only the last message will be retained.
   void Error(const base::FilePath& error_path);
 
   void CheckLocalWritableFiles();
 
   // Called when processing a file is completed with either a success or an
   // error.
   void OnPrepareFileDone(const base::FilePath& path, bool success);
 
   const std::vector<base::FilePath> paths_;
-  Profile* profile_;
+  content::BrowserContext* context_;
   const std::set<base::FilePath> directory_paths_;
   int outstanding_tasks_;
   base::FilePath error_path_;
   base::Closure on_success_;
   base::Callback<void(const base::FilePath&)> on_failure_;
 };
 
 WritableFileChecker::WritableFileChecker(
     const std::vector<base::FilePath>& paths,
-    Profile* profile,
+    content::BrowserContext* context,
     const std::set<base::FilePath>& directory_paths,
     const base::Closure& on_success,
     const base::Callback<void(const base::FilePath&)>& on_failure)
     : paths_(paths),
-      profile_(profile),
+      context_(context),
       directory_paths_(directory_paths),
       outstanding_tasks_(1),
       on_success_(on_success),
       on_failure_(on_failure) {}
 
 void WritableFileChecker::Check() {
   outstanding_tasks_ = paths_.size();
   for (const auto& path : paths_) {
     bool is_directory = directory_paths_.find(path) != directory_paths_.end();
 #if defined(OS_CHROMEOS)
     NonNativeFileSystemDelegate* delegate =
         ExtensionsAPIClient::Get()->GetNonNativeFileSystemDelegate();
-    if (delegate && delegate->IsUnderNonNativeLocalPath(profile_, path)) {
+    if (delegate && delegate->IsUnderNonNativeLocalPath(context_, path)) {
       if (is_directory) {
         delegate->IsNonNativeLocalPathDirectory(
-            profile_,
-            path,
+            context_, path,
             base::Bind(&WritableFileChecker::OnPrepareFileDone, this, path));
       } else {
         delegate->PrepareNonNativeLocalFileForWritableApp(
-            profile_,
-            path,
+            context_, path,
             base::Bind(&WritableFileChecker::OnPrepareFileDone, this, path));
       }
       continue;
     }
 #endif
     content::BrowserThread::PostTaskAndReplyWithResult(
         content::BrowserThread::FILE, FROM_HERE,
         base::Bind(&PrepareNativeLocalFileForWritableApp, path, is_directory),
         base::Bind(&WritableFileChecker::OnPrepareFileDone, this, path));
   }
@@ skipping 73 matching lines @@
 
 bool FileHandlerCanHandleEntry(const FileHandlerInfo& handler,
                                const EntryInfo& entry) {
   if (entry.is_directory)
     return handler.include_directories;
 
   return FileHandlerCanHandleFileWithMimeType(handler, entry.mime_type) ||
          FileHandlerCanHandleFileWithExtension(handler, entry.path);
 }
 
-GrantedFileEntry CreateFileEntry(Profile* profile,
+GrantedFileEntry CreateFileEntry(content::BrowserContext* context,
                                  const Extension* extension,
                                  int renderer_id,
                                  const base::FilePath& path,
                                  bool is_directory) {
   GrantedFileEntry result;
   storage::IsolatedContext* isolated_context =
       storage::IsolatedContext::GetInstance();
   DCHECK(isolated_context);
 
   result.filesystem_id = isolated_context->RegisterFileSystemForPath(
@@ skipping 11 matching lines @@
       policy->GrantDeleteFromFileSystem(renderer_id, result.filesystem_id);
     }
   }
 
   result.id = result.filesystem_id + ":" + result.registered_name;
   return result;
 }
 
 void PrepareFilesForWritableApp(
     const std::vector<base::FilePath>& paths,
-    Profile* profile,
+    content::BrowserContext* context,
     const std::set<base::FilePath>& directory_paths,
     const base::Closure& on_success,
     const base::Callback<void(const base::FilePath&)>& on_failure) {
   scoped_refptr<WritableFileChecker> checker(new WritableFileChecker(
-      paths, profile, directory_paths, on_success, on_failure));
+      paths, context, directory_paths, on_success, on_failure));
   checker->Check();
 }
 
 bool HasFileSystemWritePermission(const Extension* extension) {
   return extension->permissions_data()->HasAPIPermission(
       APIPermission::kFileSystemWrite);
 }
 
 bool ValidateFileEntryAndGetPath(const std::string& filesystem_name,
                                  const std::string& filesystem_path,
@@ skipping 42 matching lines @@
     *error = kInvalidParameters;
     return false;
   }
 
   return true;
 }
 
 }  // namespace app_file_handler_util
 
 }  // namespace extensions