chrome/browser/browsing_data/browsing_data_file_system_helper_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "testing/gtest/include/gtest/gtest.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/file_util.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/platform_file.h"
  12 #include "base/stl_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "chrome/browser/browsing_data/browsing_data_file_system_helper.h"
  15 #include "chrome/test/base/testing_profile.h"
  16 #include "content/public/browser/storage_partition.h"
  17 #include "content/public/test/test_browser_thread.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "webkit/browser/fileapi/file_system_context.h"
  20 #include "webkit/browser/fileapi/file_system_url.h"
  21 #include "webkit/common/fileapi/file_system_types.h"
  22
  23 using content::BrowserContext;
  24 using content::BrowserThread;
  25
  26 namespace {
  27
  28 // Shorter names for fileapi::* constants.
  29 const fileapi::FileSystemType kTemporary = fileapi::kFileSystemTypeTemporary;
  30 const fileapi::FileSystemType kPersistent = fileapi::kFileSystemTypePersistent;
  31
  32 // We'll use these three distinct origins for testing, both as strings and as
  33 // GURLs in appropriate contexts.
  34 const char kTestOrigin1[] = "http://host1:1/";
  35 const char kTestOrigin2[] = "http://host2:2/";
  36 const char kTestOrigin3[] = "http://host3:3/";
  37
  38 // Extensions and Devtools should be ignored.
  39 const char kTestOriginExt[] = "chrome-extension://abcdefghijklmnopqrstuvwxyz/";
  40 const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
  41
  42 const GURL kOrigin1(kTestOrigin1);
  43 const GURL kOrigin2(kTestOrigin2);
  44 const GURL kOrigin3(kTestOrigin3);
  45 const GURL kOriginExt(kTestOriginExt);
  46 const GURL kOriginDevTools(kTestOriginDevTools);
  47
  48 // TODO(mkwst): Update this size once the discussion in http://crbug.com/86114
  49 // is concluded.
  50 const int kEmptyFileSystemSize = 0;
  51
  52 typedef std::list<BrowsingDataFileSystemHelper::FileSystemInfo>
  53     FileSystemInfoList;
  54 typedef scoped_ptr<FileSystemInfoList> ScopedFileSystemInfoList;
  55
  56 // The FileSystem APIs are all asynchronous; this testing class wraps up the
  57 // boilerplate code necessary to deal with waiting for responses. In a nutshell,
  58 // any async call whose response we want to test ought to be followed by a call
  59 // to BlockUntilNotified(), which will (shockingly!) block until Notify() is
  60 // called. For this to work, you'll need to ensure that each async call is
  61 // implemented as a class method that that calls Notify() at an appropriate
  62 // point.
  63 class BrowsingDataFileSystemHelperTest : public testing::Test {
  64  public:
  65   BrowsingDataFileSystemHelperTest() {
  66     profile_.reset(new TestingProfile());
  67
  68     helper_ = BrowsingDataFileSystemHelper::Create(
  69         BrowserContext::GetDefaultStoragePartition(profile_.get())->
  70             GetFileSystemContext());
  71     base::MessageLoop::current()->RunUntilIdle();
  72     canned_helper_ = new CannedBrowsingDataFileSystemHelper(profile_.get());
  73   }
  74   virtual ~BrowsingDataFileSystemHelperTest() {
  75     // Avoid memory leaks.
  76     profile_.reset();
  77     base::MessageLoop::current()->RunUntilIdle();
  78   }
  79
  80   TestingProfile* GetProfile() {
  81     return profile_.get();
  82   }
  83
  84   // Blocks on the current MessageLoop until Notify() is called.
  85   void BlockUntilNotified() {
  86     base::MessageLoop::current()->Run();
  87   }
  88
  89   // Unblocks the current MessageLoop. Should be called in response to some sort
  90   // of async activity in a callback method.
  91   void Notify() {
  92     base::MessageLoop::current()->Quit();
  93   }
  94
  95   // Callback that should be executed in response to
  96   // fileapi::FileSystemContext::OpenFileSystem.
  97   void OpenFileSystemCallback(const GURL& root,
  98                               const std::string& name,
  99                               base::PlatformFileError error) {
 100     open_file_system_result_ = error;
 101     Notify();
 102   }
 103
 104   bool OpenFileSystem(const GURL& origin,
 105                       fileapi::FileSystemType type,
 106                       fileapi::OpenFileSystemMode open_mode) {
 107     BrowserContext::GetDefaultStoragePartition(profile_.get())->
 108         GetFileSystemContext()->OpenFileSystem(
 109             origin, type, open_mode,
 110             base::Bind(
 111                 &BrowsingDataFileSystemHelperTest::OpenFileSystemCallback,
 112                 base::Unretained(this)));
 113     BlockUntilNotified();
 114     return open_file_system_result_ == base::PLATFORM_FILE_OK;
 115   }
 116
 117   // Calls fileapi::FileSystemContext::OpenFileSystem with
 118   // OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT flag
 119   // to verify the existence of a file system for a specified type and origin,
 120   // blocks until a response is available, then returns the result
 121   // synchronously to it's caller.
 122   bool FileSystemContainsOriginAndType(const GURL& origin,
 123                                        fileapi::FileSystemType type) {
 124     return OpenFileSystem(origin, type,
 125                           fileapi::OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT);
 126   }
 127
 128   // Callback that should be executed in response to StartFetching(), and stores
 129   // found file systems locally so that they are available via GetFileSystems().
 130   void CallbackStartFetching(
 131       const std::list<BrowsingDataFileSystemHelper::FileSystemInfo>&
 132           file_system_info_list) {
 133     file_system_info_list_.reset(
 134         new std::list<BrowsingDataFileSystemHelper::FileSystemInfo>(
 135             file_system_info_list));
 136     Notify();
 137   }
 138
 139   // Calls StartFetching() on the test's BrowsingDataFileSystemHelper
 140   // object, then blocks until the callback is executed.
 141   void FetchFileSystems() {
 142     helper_->StartFetching(
 143         base::Bind(&BrowsingDataFileSystemHelperTest::CallbackStartFetching,
 144                    base::Unretained(this)));
 145     BlockUntilNotified();
 146   }
 147
 148   // Calls StartFetching() on the test's CannedBrowsingDataFileSystemHelper
 149   // object, then blocks until the callback is executed.
 150   void FetchCannedFileSystems() {
 151     canned_helper_->StartFetching(
 152         base::Bind(&BrowsingDataFileSystemHelperTest::CallbackStartFetching,
 153                    base::Unretained(this)));
 154     BlockUntilNotified();
 155   }
 156
 157   // Sets up kOrigin1 with a temporary file system, kOrigin2 with a persistent
 158   // file system, and kOrigin3 with both.
 159   virtual void PopulateTestFileSystemData() {
 160     CreateDirectoryForOriginAndType(kOrigin1, kTemporary);
 161     CreateDirectoryForOriginAndType(kOrigin2, kPersistent);
 162     CreateDirectoryForOriginAndType(kOrigin3, kTemporary);
 163     CreateDirectoryForOriginAndType(kOrigin3, kPersistent);
 164
 165     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin1, kPersistent));
 166     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin1, kTemporary));
 167     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin2, kPersistent));
 168     EXPECT_FALSE(FileSystemContainsOriginAndType(kOrigin2, kTemporary));
 169     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kPersistent));
 170     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kTemporary));
 171   }
 172
 173   // Calls OpenFileSystem with OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT
 174   // to create a filesystem of a given type for a specified origin.
 175   void CreateDirectoryForOriginAndType(const GURL& origin,
 176                                        fileapi::FileSystemType type) {
 177     OpenFileSystem(origin, type,
 178                    fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
 179     EXPECT_EQ(base::PLATFORM_FILE_OK, open_file_system_result_);
 180   }
 181
 182   // Returns a list of the FileSystemInfo objects gathered in the most recent
 183   // call to StartFetching().
 184   FileSystemInfoList* GetFileSystems() {
 185     return file_system_info_list_.get();
 186   }
 187
 188  protected:
 189   content::TestBrowserThreadBundle thread_bundle_;
 190   scoped_ptr<TestingProfile> profile_;
 191
 192   // Temporary storage to pass information back from callbacks.
 193   base::PlatformFileError open_file_system_result_;
 194   ScopedFileSystemInfoList file_system_info_list_;
 195
 196   scoped_refptr<BrowsingDataFileSystemHelper> helper_;
 197   scoped_refptr<CannedBrowsingDataFileSystemHelper> canned_helper_;
 198
 199   DISALLOW_COPY_AND_ASSIGN(BrowsingDataFileSystemHelperTest);
 200 };
 201
 202 // Verifies that the BrowsingDataFileSystemHelper correctly finds the test file
 203 // system data, and that each file system returned contains the expected data.
 204 TEST_F(BrowsingDataFileSystemHelperTest, FetchData) {
 205   PopulateTestFileSystemData();
 206
 207   FetchFileSystems();
 208
 209   EXPECT_EQ(3UL, file_system_info_list_->size());
 210
 211   // Order is arbitrary, verify all three origins.
 212   bool test_hosts_found[3] = {false, false, false};
 213   for (std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator info =
 214        file_system_info_list_->begin(); info != file_system_info_list_->end();
 215        ++info) {
 216     if (info->origin == kOrigin1) {
 217       EXPECT_FALSE(test_hosts_found[0]);
 218       test_hosts_found[0] = true;
 219       EXPECT_FALSE(ContainsKey(info->usage_map, kPersistent));
 220       EXPECT_TRUE(ContainsKey(info->usage_map, kTemporary));
 221       EXPECT_EQ(kEmptyFileSystemSize,
 222                 info->usage_map[fileapi::kFileSystemTypeTemporary]);
 223     } else if (info->origin == kOrigin2) {
 224       EXPECT_FALSE(test_hosts_found[1]);
 225       test_hosts_found[1] = true;
 226       EXPECT_TRUE(ContainsKey(info->usage_map, kPersistent));
 227       EXPECT_FALSE(ContainsKey(info->usage_map, kTemporary));
 228       EXPECT_EQ(kEmptyFileSystemSize, info->usage_map[kPersistent]);
 229     } else if (info->origin == kOrigin3) {
 230       EXPECT_FALSE(test_hosts_found[2]);
 231       test_hosts_found[2] = true;
 232       EXPECT_TRUE(ContainsKey(info->usage_map, kPersistent));
 233       EXPECT_TRUE(ContainsKey(info->usage_map, kTemporary));
 234       EXPECT_EQ(kEmptyFileSystemSize, info->usage_map[kPersistent]);
 235       EXPECT_EQ(kEmptyFileSystemSize, info->usage_map[kTemporary]);
 236     } else {
 237       ADD_FAILURE() << info->origin.spec() << " isn't an origin we added.";
 238     }
 239   }
 240   for (size_t i = 0; i < arraysize(test_hosts_found); i++) {
 241     EXPECT_TRUE(test_hosts_found[i]);
 242   }
 243 }
 244
 245 // Verifies that the BrowsingDataFileSystemHelper correctly deletes file
 246 // systems via DeleteFileSystemOrigin().
 247 TEST_F(BrowsingDataFileSystemHelperTest, DeleteData) {
 248   PopulateTestFileSystemData();
 249
 250   helper_->DeleteFileSystemOrigin(kOrigin1);
 251   helper_->DeleteFileSystemOrigin(kOrigin2);
 252
 253   FetchFileSystems();
 254
 255   EXPECT_EQ(1UL, file_system_info_list_->size());
 256   BrowsingDataFileSystemHelper::FileSystemInfo info =
 257       *(file_system_info_list_->begin());
 258   EXPECT_EQ(kOrigin3, info.origin);
 259   EXPECT_TRUE(ContainsKey(info.usage_map, kPersistent));
 260   EXPECT_TRUE(ContainsKey(info.usage_map, kTemporary));
 261   EXPECT_EQ(kEmptyFileSystemSize, info.usage_map[kPersistent]);
 262   EXPECT_EQ(kEmptyFileSystemSize, info.usage_map[kTemporary]);
 263 }
 264
 265 // Verifies that the CannedBrowsingDataFileSystemHelper correctly reports
 266 // whether or not it currently contains file systems.
 267 TEST_F(BrowsingDataFileSystemHelperTest, Empty) {
 268   ASSERT_TRUE(canned_helper_->empty());
 269   canned_helper_->AddFileSystem(kOrigin1, kTemporary, 0);
 270   ASSERT_FALSE(canned_helper_->empty());
 271   canned_helper_->Reset();
 272   ASSERT_TRUE(canned_helper_->empty());
 273 }
 274
 275 // Verifies that AddFileSystem correctly adds file systems, and that both
 276 // the type and usage metadata are reported as provided.
 277 TEST_F(BrowsingDataFileSystemHelperTest, CannedAddFileSystem) {
 278   canned_helper_->AddFileSystem(kOrigin1, kPersistent, 200);
 279   canned_helper_->AddFileSystem(kOrigin2, kTemporary, 100);
 280
 281   FetchCannedFileSystems();
 282
 283   EXPECT_EQ(2U, file_system_info_list_->size());
 284   std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator info =
 285       file_system_info_list_->begin();
 286   EXPECT_EQ(kOrigin1, info->origin);
 287   EXPECT_TRUE(ContainsKey(info->usage_map, kPersistent));
 288   EXPECT_FALSE(ContainsKey(info->usage_map, kTemporary));
 289   EXPECT_EQ(200, info->usage_map[kPersistent]);
 290
 291   info++;
 292   EXPECT_EQ(kOrigin2, info->origin);
 293   EXPECT_FALSE(ContainsKey(info->usage_map, kPersistent));
 294   EXPECT_TRUE(ContainsKey(info->usage_map, kTemporary));
 295   EXPECT_EQ(100, info->usage_map[kTemporary]);
 296 }
 297
 298 // Verifies that the CannedBrowsingDataFileSystemHelper correctly ignores
 299 // extension and devtools schemes.
 300 TEST_F(BrowsingDataFileSystemHelperTest, IgnoreExtensionsAndDevTools) {
 301   ASSERT_TRUE(canned_helper_->empty());
 302   canned_helper_->AddFileSystem(kOriginExt, kTemporary, 0);
 303   ASSERT_TRUE(canned_helper_->empty());
 304   canned_helper_->AddFileSystem(kOriginDevTools, kTemporary, 0);
 305   ASSERT_TRUE(canned_helper_->empty());
 306 }
 307
 308 }  // namespace