Run the JSON Schema Compiler's bundle compilation on JSON files. Previously it

chrome/browser/chromeos/extensions/file_browser_handler_api.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.
 
 // The file contains the implementation of
 // fileBrowserHandlerInternal.selectFile extension function.
 // When invoked, the function does the following:
 //  - Verifies that the extension function was invoked as a result of user
 //    gesture.
 //  - Display 'save as' dialog using FileSelectorImpl which waits for the user
 //    feedback.
 //  - Once the user selects the file path (or cancels the selection),
-//    FileSelectorImpl notifies FileHandlerSelectFileFunction of the selection
-//    result by calling FileHandlerSelectFile::OnFilePathSelected.
-//  - If the selection was canceled, FileHandlerSelectFileFunction returns
-//    reporting failure.
+//    FileSelectorImpl notifies FileBrowserHandlerInternalSelectFileFunction of
+//    the selection result by calling FileHandlerSelectFile::OnFilePathSelected.
+//  - If the selection was canceled,
+//    FileBrowserHandlerInternalSelectFileFunction returns reporting failure.
 //  - If the file path was selected, the function opens external file system
 //    needed to create FileEntry object for the selected path
 //    (opening file system will create file system name and root url for the
 //    caller's external file system).
 //  - The function grants permissions needed to read/write/create file under the
 //    selected path. To grant permissions to the caller, caller's extension ID
 //    has to be allowed to access the files virtual path (e.g. /Downloads/foo)
 //    in ExternalFileSystemMountPointProvider. Additionally, the callers render
 //    process ID has to be granted read, write and create permissions for the
 //    selected file's full filesystem path (e.g.
@@ skipping 85 matching lines @@
 
  protected:
   // file_handler::FileSelectr overrides.
   // Shows save as dialog with suggested name in window bound to |browser|.
   // |allowed_extensions| specifies the file extensions allowed to be shown,
   // and selected. Extensions should not include '.'.
   //
   // After this method is called, the selector implementation should not be
   // deleted by the caller. It will delete itself after it receives response
   // from SelectFielDialog.
-  virtual void SelectFile(const FilePath& suggested_name,
-                          const std::vector<std::string>& allowed_extensions,
-                          Browser* browser,
-                          FileHandlerSelectFileFunction* function) OVERRIDE;
+  virtual void SelectFile(
+      const FilePath& suggested_name,
+      const std::vector<std::string>& allowed_extensions,
+      Browser* browser,
+      FileBrowserHandlerInternalSelectFileFunction* function) OVERRIDE;
 
   // ui::SelectFileDialog::Listener overrides.
   virtual void FileSelected(const FilePath& path,
                             int index,
                             void* params) OVERRIDE;
   virtual void MultiFilesSelected(const std::vector<FilePath>& files,
                                   void* params) OVERRIDE;
   virtual void FileSelectionCanceled(void* params) OVERRIDE;
 
  private:
@@ skipping 15 matching lines @@
   // The |this| object is self destruct after the function is notified.
   // |success| indicates whether user has selectd the file.
   // |selected_path| is path that was selected. It is empty if the file wasn't
   // selected.
   void SendResponse(bool success, const FilePath& selected_path);
 
   // Dialog that is shown by selector.
   scoped_refptr<ui::SelectFileDialog> dialog_;
 
   // Extension function that uses the selector.
-  scoped_refptr<FileHandlerSelectFileFunction> function_;
+  scoped_refptr<FileBrowserHandlerInternalSelectFileFunction> function_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSelectorImpl);
 };
 
 FileSelectorImpl::FileSelectorImpl() {}
 
 FileSelectorImpl::~FileSelectorImpl() {
   if (dialog_.get())
     dialog_->ListenerDestroyed();
   // Send response if needed.
   if (function_)
     SendResponse(false, FilePath());
 }
 
 void FileSelectorImpl::SelectFile(
     const FilePath& suggested_name,
     const std::vector<std::string>& allowed_extensions,
     Browser* browser,
-    FileHandlerSelectFileFunction* function) {
+    FileBrowserHandlerInternalSelectFileFunction* function) {
   // We will hold reference to the function until it is notified of selection
   // result.
   function_ = function;
 
   if (!StartSelectFile(suggested_name, allowed_extensions, browser)) {
     // If the dialog wasn't launched, let's asynchronously report failure to the
     // function.
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
         base::Bind(&FileSelectorImpl::FileSelectionCanceled,
                    base::Unretained(this), reinterpret_cast<void*>(NULL)));
@@ skipping 91 matching lines @@
     const FileSystemOpenCallback& callback,
     base::PlatformFileError error,
     const std::string& file_system_name,
     const GURL& file_system_root) {
   bool success = (error == base::PLATFORM_FILE_OK);
   callback.Run(success, file_system_name, file_system_root);
 }
 
 }  // namespace
 
-FileHandlerSelectFileFunction::FileHandlerSelectFileFunction()
-    : file_selector_factory_(new FileSelectorFactoryImpl()),
-      user_gesture_check_enabled_(true) {
+FileBrowserHandlerInternalSelectFileFunction::
+    FileBrowserHandlerInternalSelectFileFunction()
+        : file_selector_factory_(new FileSelectorFactoryImpl()),
+          user_gesture_check_enabled_(true) {
 }
 
-FileHandlerSelectFileFunction::FileHandlerSelectFileFunction(
-    FileSelectorFactory* file_selector_factory,
-    bool enable_user_gesture_check)
-    : file_selector_factory_(file_selector_factory),
-      user_gesture_check_enabled_(enable_user_gesture_check) {
+FileBrowserHandlerInternalSelectFileFunction::
+    FileBrowserHandlerInternalSelectFileFunction(
+        FileSelectorFactory* file_selector_factory,
+        bool enable_user_gesture_check)
+        : file_selector_factory_(file_selector_factory),
+          user_gesture_check_enabled_(enable_user_gesture_check) {
   DCHECK(file_selector_factory);
 }
 
-FileHandlerSelectFileFunction::~FileHandlerSelectFileFunction() {}
+FileBrowserHandlerInternalSelectFileFunction::
+    ~FileBrowserHandlerInternalSelectFileFunction() {}
 
-bool FileHandlerSelectFileFunction::RunImpl() {
+bool FileBrowserHandlerInternalSelectFileFunction::RunImpl() {
   scoped_ptr<SelectFile::Params> params(SelectFile::Params::Create(*args_));
 
   FilePath suggested_name(params->selection_params.suggested_name);
   std::vector<std::string> allowed_extensions;
   if (params->selection_params.allowed_file_extensions.get())
     allowed_extensions = *params->selection_params.allowed_file_extensions;
 
   if (!user_gesture() && user_gesture_check_enabled_) {
     error_ = kNoUserGestureError;
     return false;
   }
 
   FileSelector* file_selector = file_selector_factory_->CreateFileSelector();
   file_selector->SelectFile(suggested_name.BaseName(),
                             allowed_extensions,
                             GetCurrentBrowser(),
                             this);
   return true;
 }
 
-void FileHandlerSelectFileFunction::OnFilePathSelected(
+void FileBrowserHandlerInternalSelectFileFunction::OnFilePathSelected(
     bool success,
     const FilePath& full_path) {
   if (!success) {
     Respond(false);
     return;
   }
 
   full_path_ = full_path;
 
   // We have to open file system in order to create a FileEntry object for the
   // selected file path.
   BrowserContext::GetDefaultStoragePartition(profile_)->
       GetFileSystemContext()->OpenFileSystem(
           source_url_.GetOrigin(), fileapi::kFileSystemTypeExternal, false,
           base::Bind(
               &RunOpenFileSystemCallback,
-              base::Bind(&FileHandlerSelectFileFunction::OnFileSystemOpened,
+              base::Bind(&FileBrowserHandlerInternalSelectFileFunction::
+                             OnFileSystemOpened,
                          this)));
 };
 
-void FileHandlerSelectFileFunction::OnFileSystemOpened(
+void FileBrowserHandlerInternalSelectFileFunction::OnFileSystemOpened(
     bool success,
     const std::string& file_system_name,
     const GURL& file_system_root) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!success) {
     Respond(false);
     return;
   }
 
   // Remember opened file system's parameters.
   file_system_name_ = file_system_name;
   file_system_root_ = file_system_root;
 
   GrantPermissions();
 }
 
-void FileHandlerSelectFileFunction::GrantPermissions() {
+void FileBrowserHandlerInternalSelectFileFunction::GrantPermissions() {
   fileapi::ExternalFileSystemMountPointProvider* external_provider =
       BrowserContext::GetDefaultStoragePartition(profile_)->
       GetFileSystemContext()->external_provider();
   DCHECK(external_provider);
 
   external_provider->GetVirtualPath(full_path_, &virtual_path_);
   DCHECK(!virtual_path_.empty());
 
   // Grant access to this particular file to target extension. This will
   // ensure that the target extension can access only this FS entry and
@@ skipping 15 matching lines @@
 
   // For drive files, we also have to grant permissions for drive cache paths
   // under which the selected path could be kept.
   scoped_ptr<std::vector<FilePath> > gdata_paths(new std::vector<FilePath>());
   gdata_paths->push_back(virtual_path_);
 
   drive::util::InsertDriveCachePathsPermissions(
       profile(),
       gdata_paths.Pass(),
       &permissions_to_grant_,
-      base::Bind(&FileHandlerSelectFileFunction::OnGotPermissionsToGrant,
+      base::Bind(&FileBrowserHandlerInternalSelectFileFunction::
+                     OnGotPermissionsToGrant,
                  this));
 }
 
-void FileHandlerSelectFileFunction::OnGotPermissionsToGrant() {
+void FileBrowserHandlerInternalSelectFileFunction::OnGotPermissionsToGrant() {
   // At this point all needed permissions should be collected, so let's grant
   // them.
   for (size_t i = 0; i < permissions_to_grant_.size(); i++) {
     content::ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
         render_view_host()->GetProcess()->GetID(),
         permissions_to_grant_[i].first,
         permissions_to_grant_[i].second);
   }
 
   Respond(true);
 }
 
-void FileHandlerSelectFileFunction::Respond(bool success) {
+void FileBrowserHandlerInternalSelectFileFunction::Respond(bool success) {
   scoped_ptr<SelectFile::Results::Result> result(
       new SelectFile::Results::Result());
   result->success = success;
 
   // If the file was selected, add 'entry' object which will be later used to
   // create a FileEntry instance for the selected file.
   if (success) {
     result->entry.reset(new FileEntryInfo());
     result->entry->file_system_name = file_system_name_;
     result->entry->file_system_root = file_system_root_.spec();
     result->entry->file_full_path = "/" + virtual_path_.value();
     result->entry->file_is_directory = false;
   }
 
   results_ = SelectFile::Results::Create(*result);
   SendResponse(true);
 }