New FileSystemURL cracking

chrome/browser/chromeos/extensions/file_handler_util.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_HANDLER_UTIL_H_
 #define CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_HANDLER_UTIL_H_
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/platform_file.h"
 #include "chrome/common/extensions/extension.h"
 #include "extensions/common/url_pattern_set.h"
 
 class Browser;
 class FileBrowserHandler;
 class GURL;
 class Profile;
 
 namespace extensions {
 class Extension;
 }  // namespace extensions
 
+namespace fileapi {
+class FileSystemURL;
+}
+
 namespace file_handler_util {
 
 // Specifies the task type for a task id that represents some file action, Drive
 // action, or Web Intent action.
 extern const char kTaskFile[];
 extern const char kTaskDrive[];
 extern const char kTaskWebIntent[];
 extern const char kTaskApp[];
 
 void UpdateFileHandlerUsageStats(Profile* profile, const std::string& task_id);
@@ skipping 61 matching lines @@
   // Creates the appropriate FileTaskExecutor for the given |extension_id|.
   static FileTaskExecutor* Create(Profile* profile,
                                   const GURL& source_url,
                                   const std::string& file_browser_id,
                                   int32 tab_id,
                                   const std::string& extension_id,
                                   const std::string& task_type,
                                   const std::string& action_id);
 
   // Same as ExecuteAndNotify, but no notification is performed.
-  virtual bool Execute(const std::vector<GURL>& file_urls);
+  virtual bool Execute(const std::vector<fileapi::FileSystemURL>& file_urls);
 
   // Initiates execution of file handler task for each element of |file_urls|.
   // Return |false| if the execution cannot be initiated. Otherwise returns
   // |true| and then eventually calls |done| when all the files have
   // been handled. If there is an error during processing the list of files, the
   // caller will be informed of the failure via |done|, and the rest of
   // the files will not be processed.
-  virtual bool ExecuteAndNotify(const std::vector<GURL>& file_urls,
-                                const FileTaskFinishedCallback& done) = 0;
+  virtual bool ExecuteAndNotify(
+      const std::vector<fileapi::FileSystemURL>& file_urls,
+      const FileTaskFinishedCallback& done) = 0;
 
  protected:
   explicit FileTaskExecutor(Profile* profile,
                             const GURL& source_url,
                             const std::string& file_browser_id,
                             const std::string& extension_id);
   virtual ~FileTaskExecutor();
 
   // Checks if the file browser extension had file access permissions for the
   // list of files.
-  bool FileBrowserHasAccessPermissionForFiles(const std::vector<GURL>& files);
+  bool FileBrowserHasAccessPermissionForFiles(
+      const std::vector<fileapi::FileSystemURL>& files);
 
   // Returns the profile that this task was created with.
   Profile* profile() { return profile_; }
 
   // Returns a browser to use for the current browser.
   Browser* GetBrowser() const;
 
   // Returns the extension for this profile.
   const extensions::Extension* GetExtension();
 
   // Returns the extension ID set for this FileTaskExecutor.
   const std::string& extension_id() { return extension_id_; }
 
  private:
   friend class base::RefCountedThreadSafe<FileTaskExecutor>;
 
   Profile* profile_;
   const GURL source_url_;
   const std::string file_browser_id_;
   const std::string extension_id_;
 };
 
 }  // namespace file_handler_util
 
 #endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_FILE_HANDLER_UTIL_H_