[NaCl SDK] Refactor FakeHtml5FsFilesystem and FakeHtml5FsNode.

native_client_sdk/src/tests/nacl_io_test/html5_fs_test.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 <errno.h>
 #include <fcntl.h>
 
 #include <set>
 #include <string>
 
-#include <gmock/gmock.h>
-#include <ppapi/c/ppb_file_io.h>
-#include <ppapi/c/pp_directory_entry.h>
-#include <ppapi/c/pp_errors.h>
-#include <ppapi/c/pp_instance.h>
-#if defined(WIN32)
-#include <windows.h>  // For Sleep()
-#endif
+#include <ppapi/c/pp_file_info.h>
 
+#include "fake_ppapi/fake_node.h"
 #include "fake_ppapi/fake_pepper_interface_html5_fs.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/html5fs/html5_fs.h"
 #include "nacl_io/osdirent.h"
-#include "nacl_io/osunistd.h"
 #include "nacl_io/pepper_interface_delegate.h"
 #include "sdk_util/scoped_ref.h"
 #include "mock_util.h"
 #include "pepper_interface_mock.h"
 
 using namespace nacl_io;
 using namespace sdk_util;
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::Return;
 
 namespace {
 
 class Html5FsForTesting : public Html5Fs {
  public:
-  Html5FsForTesting(StringMap_t& string_map, PepperInterface* ppapi,
+  Html5FsForTesting(StringMap_t& string_map,
+                    PepperInterface* ppapi,
                     int expected_error = 0) {
     FsInitArgs args;
     args.string_map = string_map;
     args.ppapi = ppapi;
     Error error = Init(args);
     EXPECT_EQ(expected_error, error);
   }
 
   bool Exists(const char* filename) {
     ScopedNode node;
@@ skipping 47 matching lines @@
   for (int i = 0; filesystem_type_strings[i] != NULL; ++i) {
     const char* filesystem_type_string = filesystem_type_strings[i];
     PP_FileSystemType expected_filesystem_type = filesystem_type_values[i];
 
     for (int j = 0; expected_size_strings[j] != NULL; ++j) {
       const char* expected_size_string = expected_size_strings[j];
       int64_t expected_expected_size = expected_size_values[j];
 
       ppapi_.SetFileSystemInterfaceDelegate(filesystem_mock);
 
-      ON_CALL(*filesystem_mock, Create(_, _)).WillByDefault(
-          Invoke(filesystem_fake, &FakeFileSystemInterface::Create));
+      ON_CALL(*filesystem_mock, Create(_, _))
+          .WillByDefault(
+              Invoke(filesystem_fake, &FakeFileSystemInterface::Create));
 
       EXPECT_CALL(*filesystem_mock,
                   Create(ppapi_.GetInstance(), expected_filesystem_type));
 
       EXPECT_CALL(*filesystem_mock, Open(_, expected_expected_size, _))
           .WillOnce(DoAll(CallCallback<2>(int32_t(PP_OK)),
                           Return(int32_t(PP_OK_COMPLETIONPENDING))));
 
       StringMap_t map;
       map["type"] = filesystem_type_string;
@@ skipping 13 matching lines @@
     ScopedRef<Html5FsForTesting> fs(
         new Html5FsForTesting(map, &ppapi_, EINVAL));
   }
 
   {
     EXPECT_TRUE(ppapi_html5_.filesystem_template()->AddEmptyFile("/foo", NULL));
     PP_Resource filesystem = ppapi_html5_.GetFileSystemInterface()->Create(
         ppapi_html5_.GetInstance(), PP_FILESYSTEMTYPE_LOCALPERSISTENT);
 
     ASSERT_EQ(int32_t(PP_OK), ppapi_html5_.GetFileSystemInterface()->Open(
-              filesystem, 0, PP_BlockUntilComplete()));
+                                  filesystem, 0, PP_BlockUntilComplete()));
 
     StringMap_t map;
     char buffer[30];
     snprintf(buffer, 30, "%d", filesystem);
     map["filesystem_resource"] = buffer;
-    ScopedRef<Html5FsForTesting> fs(
-        new Html5FsForTesting(map, &ppapi_));
+    ScopedRef<Html5FsForTesting> fs(new Html5FsForTesting(map, &ppapi_));
 
     ASSERT_TRUE(fs->Exists("/foo"));
 
     ppapi_html5_.GetCoreInterface()->ReleaseResource(filesystem);
   }
 }
 
 TEST_F(Html5FsTest, MountSubtree) {
-  EXPECT_TRUE(ppapi_html5_.filesystem_template()->AddEmptyFile("/foo/bar",
-                                                               NULL));
+  EXPECT_TRUE(
+      ppapi_html5_.filesystem_template()->AddEmptyFile("/foo/bar", NULL));
   StringMap_t map;
   map["SOURCE"] = "/foo";
   ScopedRef<Html5FsForTesting> fs(new Html5FsForTesting(map, &ppapi_));
 
   ASSERT_TRUE(fs->Exists("/bar"));
   ASSERT_FALSE(fs->Exists("/foo/bar"));
 }
 
 TEST_F(Html5FsTest, Mkdir) {
   StringMap_t map;
@@ skipping 75 matching lines @@
 
   EXPECT_FALSE(fs->Exists("/foo"));
 
   Path path("/foo");
   ScopedNode node;
   ASSERT_EQ(0, fs->Open(path, O_CREAT | O_RDWR, &node));
 
   // Write some data.
   const char* contents = "contents";
   int bytes_written = 0;
-  EXPECT_EQ(0, node->Write(HandleAttr(), contents, strlen(contents),
-                           &bytes_written));
+  EXPECT_EQ(
+      0, node->Write(HandleAttr(), contents, strlen(contents), &bytes_written));
   EXPECT_EQ(strlen(contents), bytes_written);
 
   // Create again.
   ASSERT_EQ(0, fs->Open(path, O_CREAT, &node));
 
   // Check that the file still has data.
   off_t size;
   EXPECT_EQ(0, node->GetSize(&size));
   EXPECT_EQ(strlen(contents), size);
 
@@ skipping 91 matching lines @@
   EXPECT_EQ(EISDIR, node->Write(attr, &buffer[0], sizeof(buffer), &bytes_read));
 }
 
 TEST_F(Html5FsTest, GetStat) {
   const int creation_time = 1000;
   const int access_time = 2000;
   const int modified_time = 3000;
   const char* contents = "contents";
 
   // Create fake file.
-  FakeHtml5FsNode* fake_node;
-  EXPECT_TRUE(ppapi_html5_.filesystem_template()->AddFile(
-      "/file", contents, &fake_node));
+  FakeNode* fake_node;
+  EXPECT_TRUE(ppapi_html5_.filesystem_template()->AddFile("/file", contents,
+                                                          &fake_node));
   fake_node->set_creation_time(creation_time);
   fake_node->set_last_access_time(access_time);
   fake_node->set_last_modified_time(modified_time);
 
   // Create fake directory.
   EXPECT_TRUE(
       ppapi_html5_.filesystem_template()->AddDirectory("/dir", &fake_node));
   fake_node->set_creation_time(creation_time);
   fake_node->set_last_access_time(access_time);
   fake_node->set_last_modified_time(modified_time);
@@ skipping 162 matching lines @@
         EXPECT_EQ(dirents[i].d_ino, file2_ino);
       }
     }
 
     EXPECT_EQ(1, dirnames.count("file"));
     EXPECT_EQ(1, dirnames.count("file2"));
     EXPECT_EQ(1, dirnames.count("."));
     EXPECT_EQ(1, dirnames.count(".."));
   }
 }