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

chrome/browser/chromeos/extensions/file_browser_handler_api_test.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.
 
 // File contains browser tests for the fileBrowserHandler api.
 
 #include "chrome/browser/chromeos/extensions/file_browser_handler_api.h"
 
 #include <vector>
 
@@ skipping 46 matching lines @@
 
 // Checks that file under path |selected_path| contains |expected_contents|.
 // Must be called on the file thread.
 void ExpectFileContentEquals(const FilePath& selected_path,
                              const std::string& expected_contents) {
   std::string test_file_contents;
   ASSERT_TRUE(file_util::ReadFileToString(selected_path, &test_file_contents));
   EXPECT_EQ(expected_contents, test_file_contents);
 }
 
-// Mocks FileSelector used by FileHandlerSelectFileFunction.
+// Mocks FileSelector used by FileBrowserHandlerInternalSelectFileFunction.
 // When |SelectFile| is called, it will check that file name suggestion is as
 // expected, and respond to the extension function with specified selection
 // results.
 class MockFileSelector : public file_handler::FileSelector {
  public:
   MockFileSelector(const FilePath& suggested_name,
                    const std::vector<std::string>& allowed_extensions,
                    bool success,
                    const FilePath& selected_path)
       : suggested_name_(suggested_name),
         allowed_extensions_(allowed_extensions),
         success_(success),
         selected_path_(selected_path) {
   }
   virtual ~MockFileSelector() {}
 
   // file_handler::FileSelector implementation.
   // |browser| is not used.
-  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 {
     // Confirm that the function suggested us the right name.
     EXPECT_EQ(suggested_name_, suggested_name);
     // Confirm that the function allowed us the right extensions.
     EXPECT_EQ(allowed_extensions_.size(), allowed_extensions.size());
     if (allowed_extensions_.size() == allowed_extensions.size()) {
       for (size_t i = 0; i < allowed_extensions_.size(); ++i) {
         EXPECT_EQ(allowed_extensions_[i], allowed_extensions[i]);
       }
     }
 
     // Send response to the extension function.
     // The callback will take a reference to the function and keep it alive.
     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
-        base::Bind(&FileHandlerSelectFileFunction::OnFilePathSelected,
-            function, success_, selected_path_));
+        base::Bind(&FileBrowserHandlerInternalSelectFileFunction::
+                       OnFilePathSelected,
+                   function, success_, selected_path_));
     delete this;
   }
 
  private:
   // File name that is expected to be suggested by the function.
   FilePath suggested_name_;
 
   // Extensions that is expected to be allowed by the function.
   std::vector<std::string> allowed_extensions_;
 
@@ skipping 60 matching lines @@
     fileapi::ExternalFileSystemMountPointProvider* provider =
         BrowserContext::GetDefaultStoragePartition(browser()->profile())->
             GetFileSystemContext()->external_provider();
     provider->AddLocalMountPoint(tmp_mount_point_);
   }
 
   FilePath GetFullPathOnTmpMountPoint(const FilePath& relative_path) {
     return tmp_mount_point_.Append(relative_path);
   }
 
-  // Creates a new FileHandlerSelectFileFunction to be used in the test.
-  // This function will be called from ExtensionFunctinoDispatcher whenever
-  // an extension function for fileBrowserHandlerInternal.selectFile will be
-  // needed.
+  // Creates a new FileBrowserHandlerInternalSelectFileFunction to be used in
+  // the test.  This function will be called from ExtensionFunctinoDispatcher
+  // whenever an extension function for fileBrowserHandlerInternal.selectFile
+  // will be needed.
   static ExtensionFunction* TestSelectFileFunctionFactory() {
     EXPECT_TRUE(test_cases_);
     EXPECT_TRUE(current_test_case_ < test_cases_->size());
 
     // If this happens, test failed. But, we still don't want to crash, so
     // return valid extension function.
     if (!test_cases_ && current_test_case_ >= test_cases_->size())
-      return new FileHandlerSelectFileFunction();
+      return new FileBrowserHandlerInternalSelectFileFunction();
 
     // Create file creator factory for the current test case.
     MockFileSelectorFactory* mock_factory =
         new MockFileSelectorFactory(test_cases_->at(current_test_case_));
     current_test_case_++;
 
-    return new FileHandlerSelectFileFunction(mock_factory, false);
+    return new FileBrowserHandlerInternalSelectFileFunction(
+        mock_factory, false);
   }
 
   // Sets up test parameters for extension function invocations that will be
   // made during the test.
   void SetTestCases(const std::vector<TestCase>* test_cases) {
     test_cases_ = test_cases;
     current_test_case_ = 0;
   }
 
  private:
@@ skipping 68 matching lines @@
   // Make sure test doesn't finish until we check on file thread that the
   // selected file's content is as expected.
   content::RunAllPendingInMessageLoop(content::BrowserThread::FILE);
 
   SetTestCases(NULL);
 }
 
 // Tests that verifies the fileBrowserHandlerInternal.selectFile function fails
 // when invoked without user gesture.
 IN_PROC_BROWSER_TEST_F(FileBrowserHandlerExtensionTest, NoUserGesture) {
-  scoped_refptr<FileHandlerSelectFileFunction> select_file_function(
-      new FileHandlerSelectFileFunction());
+  scoped_refptr<FileBrowserHandlerInternalSelectFileFunction>
+      select_file_function(
+          new FileBrowserHandlerInternalSelectFileFunction());
 
   std::string error =
       utils::RunFunctionAndReturnError(
           select_file_function.get(),
           "[{\"suggestedName\": \"foo\"}]",
           browser());
 
   const std::string expected_error =
       "This method can only be called in response to user gesture, such as a "
       "mouse click or key press.";
   EXPECT_EQ(expected_error, error);
 }
 
 // Tests that checks that the fileHandlerInternal.selectFile function returns
 // dictionary with |success == false| and no file entry when user cancels file
 // selection.
 IN_PROC_BROWSER_TEST_F(FileBrowserHandlerExtensionTest, SelectionFailed) {
   TestCase test_case(FilePath("some_file_name.txt"),
                      std::vector<std::string>(),
                      false,
                      FilePath());
 
-  scoped_refptr<FileHandlerSelectFileFunction> select_file_function(
-      new FileHandlerSelectFileFunction(new MockFileSelectorFactory(test_case),
-                                        false));
+  scoped_refptr<FileBrowserHandlerInternalSelectFileFunction>
+      select_file_function(
+          new FileBrowserHandlerInternalSelectFileFunction(
+              new MockFileSelectorFactory(test_case),
+              false));
 
   select_file_function->set_has_callback(true);
   select_file_function->set_user_gesture(true);
 
   scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
       utils::RunFunctionAndReturnSingleResult(
           select_file_function.get(),
           "[{\"suggestedName\": \"some_file_name.txt\"}]",
           browser())));
 
   EXPECT_FALSE(utils::GetBoolean(result.get(), "success"));
   DictionaryValue* entry_info;
   EXPECT_FALSE(result->GetDictionary("entry", &entry_info));
 }
 
 // Tests that user cannot be suggested a full file path when selecting a file,
 // only a file name (i.e. that extension function caller has no influence on
 // which directory contents will be initially displayed in selection dialog).
 IN_PROC_BROWSER_TEST_F(FileBrowserHandlerExtensionTest, SuggestedFullPath) {
   TestCase test_case(FilePath("some_file_name.txt"),
                      std::vector<std::string>(),
                      false,
                      FilePath());
 
-  scoped_refptr<FileHandlerSelectFileFunction> select_file_function(
-      new FileHandlerSelectFileFunction(new MockFileSelectorFactory(test_case),
-                                        false));
+  scoped_refptr<FileBrowserHandlerInternalSelectFileFunction>
+      select_file_function(
+          new FileBrowserHandlerInternalSelectFileFunction(
+              new MockFileSelectorFactory(test_case),
+              false));
 
   select_file_function->set_has_callback(true);
   select_file_function->set_user_gesture(true);
 
   scoped_ptr<base::DictionaryValue> result(utils::ToDictionary(
       utils::RunFunctionAndReturnSingleResult(
           select_file_function.get(),
           "[{\"suggestedName\": \"/path_to_file/some_file_name.txt\"}]",
           browser())));
 
   EXPECT_FALSE(utils::GetBoolean(result.get(), "success"));
   DictionaryValue* entry_info;
   EXPECT_FALSE(result->GetDictionary("entry", &entry_info));
 }
 
 }  // namespace