src/chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store_unittest.cc

   1 // Copyright 2013 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 "chrome/browser/sync_file_system/drive_backend_v1/drive_metadata_store.h"
   6
   7 #include <utility>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/files/scoped_temp_dir.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/single_thread_task_runner.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/string_number_conversions.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/threading/thread.h"
  17 #include "base/values.h"
  18 #include "chrome/browser/sync_file_system/drive_backend/metadata_db_migration_util.h"
  19 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_service.h"
  20 #include "chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_util.h"
  21 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
  22 #include "chrome/browser/sync_file_system/syncable_file_system_util.h"
  23 #include "content/public/browser/browser_thread.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "third_party/leveldatabase/src/include/leveldb/db.h"
  26 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
  27 #include "webkit/browser/fileapi/isolated_context.h"
  28
  29 #define FPL FILE_PATH_LITERAL
  30
  31 using content::BrowserThread;
  32
  33 namespace sync_file_system {
  34
  35 namespace {
  36
  37 const char kOrigin[] = "chrome-extension://example";
  38
  39 typedef DriveMetadataStore::ResourceIdByOrigin ResourceIdByOrigin;
  40 typedef DriveMetadataStore::OriginByResourceId OriginByResourceId;
  41
  42 fileapi::FileSystemURL URL(const base::FilePath& path) {
  43   return CreateSyncableFileSystemURL(GURL(kOrigin), path);
  44 }
  45
  46 std::string GetResourceID(const ResourceIdByOrigin& sync_origins,
  47                           const GURL& origin) {
  48   ResourceIdByOrigin::const_iterator itr = sync_origins.find(origin);
  49   if (itr == sync_origins.end())
  50     return std::string();
  51   return itr->second;
  52 }
  53
  54 std::string CreateResourceId(const std::string& resource_id) {
  55   return IsDriveAPIDisabled() ? resource_id
  56                               : drive_backend::RemoveWapiIdPrefix(resource_id);
  57 }
  58
  59 DriveMetadata CreateMetadata(const std::string& resource_id,
  60                              const std::string& md5_checksum,
  61                              bool conflicted,
  62                              bool to_be_fetched,
  63                              DriveMetadata_ResourceType file_type) {
  64   DriveMetadata metadata;
  65   metadata.set_resource_id(CreateResourceId(resource_id));
  66   metadata.set_md5_checksum(md5_checksum);
  67   metadata.set_conflicted(conflicted);
  68   metadata.set_to_be_fetched(to_be_fetched);
  69   metadata.set_type(file_type);
  70   return metadata;
  71 }
  72
  73 }  // namespace
  74
  75 class DriveMetadataStoreTest : public testing::Test {
  76  public:
  77   DriveMetadataStoreTest()
  78       : created_(false) {}
  79
  80   virtual ~DriveMetadataStoreTest() {}
  81
  82   virtual void SetUp() OVERRIDE {
  83     file_thread_.reset(new base::Thread("Thread_File"));
  84     file_thread_->Start();
  85
  86     ui_task_runner_ = base::MessageLoopProxy::current();
  87     file_task_runner_ = file_thread_->message_loop_proxy();
  88
  89     ASSERT_TRUE(base_dir_.CreateUniqueTempDir());
  90     RegisterSyncableFileSystem();
  91   }
  92
  93   virtual void TearDown() OVERRIDE {
  94     SetDisableDriveAPI(false);
  95     RevokeSyncableFileSystem();
  96
  97     DropDatabase();
  98     file_thread_->Stop();
  99     message_loop_.RunUntilIdle();
 100   }
 101
 102  protected:
 103   void InitializeDatabase() {
 104     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
 105
 106     bool done = false;
 107     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 108     bool created = false;
 109
 110     drive_metadata_store_.reset(
 111         new DriveMetadataStore(base_dir_.path(), file_task_runner_.get()));
 112     drive_metadata_store_->Initialize(
 113         base::Bind(&DriveMetadataStoreTest::DidInitializeDatabase,
 114                    base::Unretained(this),
 115                    &done,
 116                    &status,
 117                    &created));
 118     message_loop_.Run();
 119
 120     EXPECT_TRUE(done);
 121     EXPECT_EQ(SYNC_STATUS_OK, status);
 122
 123     if (created) {
 124       EXPECT_FALSE(created_);
 125       created_ = created;
 126       return;
 127     }
 128     EXPECT_TRUE(created_);
 129   }
 130
 131   void DropDatabase() {
 132     EXPECT_TRUE(ui_task_runner_->RunsTasksOnCurrentThread());
 133     drive_metadata_store_.reset();
 134   }
 135
 136   SyncStatusCode EnableOrigin(const GURL& origin) {
 137     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 138     drive_metadata_store_->EnableOrigin(
 139         origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
 140                            base::Unretained(this), &status));
 141     message_loop_.Run();
 142     return status;
 143   }
 144
 145   SyncStatusCode DisableOrigin(const GURL& origin) {
 146     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 147     drive_metadata_store_->DisableOrigin(
 148         origin, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
 149                            base::Unretained(this), &status));
 150     message_loop_.Run();
 151     return status;
 152   }
 153
 154   SyncStatusCode RemoveOrigin(const GURL& url) {
 155     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 156     drive_metadata_store_->RemoveOrigin(
 157         url, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
 158                         base::Unretained(this), &status));
 159     message_loop_.Run();
 160     return status;
 161   }
 162
 163   SyncStatusCode UpdateEntry(const fileapi::FileSystemURL& url,
 164                              const DriveMetadata& metadata) {
 165     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 166     drive_metadata_store_->UpdateEntry(
 167         url, metadata,
 168         base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
 169                    base::Unretained(this), &status));
 170     message_loop_.Run();
 171     return status;
 172   }
 173
 174   SyncStatusCode DeleteEntry(const fileapi::FileSystemURL& url) {
 175     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 176     drive_metadata_store_->DeleteEntry(
 177         url,
 178         base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
 179                    base::Unretained(this), &status));
 180     message_loop_.Run();
 181     return status;
 182   }
 183
 184   SyncStatusCode SetLargestChangeStamp(int64 changestamp) {
 185     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 186     drive_metadata_store_->SetLargestChangeStamp(
 187         changestamp, base::Bind(&DriveMetadataStoreTest::DidFinishDBTask,
 188                                 base::Unretained(this), &status));
 189     message_loop_.Run();
 190     return status;
 191   }
 192
 193   void DidFinishDBTask(SyncStatusCode* status_out,
 194                        SyncStatusCode status) {
 195     *status_out = status;
 196     message_loop_.Quit();
 197   }
 198
 199   void MarkAsCreated() {
 200     created_ = true;
 201   }
 202
 203   void VerifyUntrackedOrigin(const GURL& origin) {
 204     EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
 205     EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
 206   }
 207
 208   void VerifyIncrementalSyncOrigin(const GURL& origin,
 209                                    const std::string& resource_id) {
 210     EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(origin));
 211     EXPECT_FALSE(metadata_store()->IsOriginDisabled(origin));
 212     EXPECT_EQ(resource_id,
 213               GetResourceID(metadata_store()->incremental_sync_origins(),
 214                             origin));
 215   }
 216
 217   void VerifyDisabledOrigin(const GURL& origin,
 218                             const std::string& resource_id) {
 219     EXPECT_FALSE(metadata_store()->IsIncrementalSyncOrigin(origin));
 220     EXPECT_TRUE(metadata_store()->IsOriginDisabled(origin));
 221     EXPECT_EQ(resource_id,
 222               GetResourceID(metadata_store()->disabled_origins(), origin));
 223   }
 224
 225   base::FilePath base_dir() {
 226     return base_dir_.path();
 227   }
 228
 229   DriveMetadataStore* metadata_store() {
 230     return drive_metadata_store_.get();
 231   }
 232
 233   leveldb::DB* metadata_db() {
 234     return drive_metadata_store_->GetDBInstanceForTesting();
 235   }
 236
 237   const DriveMetadataStore::MetadataMap& metadata_map() {
 238     return drive_metadata_store_->metadata_map_;
 239   }
 240
 241   void VerifyReverseMap() {
 242     const ResourceIdByOrigin& incremental_sync_origins =
 243         drive_metadata_store_->incremental_sync_origins_;
 244     const ResourceIdByOrigin& disabled_origins =
 245         drive_metadata_store_->disabled_origins_;
 246     const OriginByResourceId& origin_by_resource_id =
 247         drive_metadata_store_->origin_by_resource_id_;
 248
 249     size_t expected_size = incremental_sync_origins.size() +
 250                            disabled_origins.size();
 251     size_t actual_size = origin_by_resource_id.size();
 252     EXPECT_EQ(expected_size, actual_size);
 253     EXPECT_TRUE(VerifyReverseMapInclusion(incremental_sync_origins,
 254                                           origin_by_resource_id));
 255     EXPECT_TRUE(VerifyReverseMapInclusion(disabled_origins,
 256                                           origin_by_resource_id));
 257   }
 258
 259   void ReadWrite_Body();
 260   void GetConflictURLs_Body();
 261   void GetToBeFetchedFiles_Body();
 262   void StoreSyncRootDirectory_Body();
 263   void StoreSyncOrigin_Body();
 264   void DisableOrigin_Body();
 265   void RemoveOrigin_Body();
 266   void GetResourceIdForOrigin_Body();
 267   void ResetOriginRootDirectory_Body();
 268   void GetFileMetadataMap_Body();
 269
 270  private:
 271   void DidInitializeDatabase(bool* done_out,
 272                              SyncStatusCode* status_out,
 273                              bool* created_out,
 274                              SyncStatusCode status,
 275                              bool created) {
 276     *done_out = true;
 277     *status_out = status;
 278     *created_out = created;
 279     message_loop_.Quit();
 280   }
 281
 282   bool VerifyReverseMapInclusion(const ResourceIdByOrigin& left,
 283                                  const OriginByResourceId& right) {
 284     for (ResourceIdByOrigin::const_iterator itr = left.begin();
 285          itr != left.end(); ++itr) {
 286       OriginByResourceId::const_iterator found = right.find(itr->second);
 287       if (found == right.end() || found->second != itr->first)
 288         return false;
 289     }
 290     return true;
 291   }
 292
 293   base::ScopedTempDir base_dir_;
 294
 295   base::MessageLoop message_loop_;
 296   scoped_ptr<base::Thread> file_thread_;
 297
 298   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 299   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 300
 301   scoped_ptr<DriveMetadataStore> drive_metadata_store_;
 302
 303   bool created_;
 304
 305   DISALLOW_COPY_AND_ASSIGN(DriveMetadataStoreTest);
 306 };
 307
 308 void DriveMetadataStoreTest::ReadWrite_Body() {
 309   InitializeDatabase();
 310
 311   const fileapi::FileSystemURL url = URL(base::FilePath());
 312   DriveMetadata metadata;
 313   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND,
 314             metadata_store()->ReadEntry(url, &metadata));
 315
 316   metadata = CreateMetadata(
 317       "file:1234567890", "09876543210", true, false,
 318       DriveMetadata_ResourceType_RESOURCE_TYPE_FILE);
 319   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(url, metadata));
 320   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 321
 322   DropDatabase();
 323   InitializeDatabase();
 324
 325   EXPECT_EQ(1, metadata_store()->GetLargestChangeStamp());
 326
 327   DriveMetadata metadata2;
 328   EXPECT_EQ(SYNC_STATUS_OK,
 329             metadata_store()->ReadEntry(url, &metadata2));
 330   EXPECT_EQ(metadata.resource_id(), metadata2.resource_id());
 331   EXPECT_EQ(metadata.md5_checksum(), metadata2.md5_checksum());
 332   EXPECT_EQ(metadata.conflicted(), metadata2.conflicted());
 333
 334   EXPECT_EQ(SYNC_STATUS_OK, DeleteEntry(url));
 335   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND,
 336             metadata_store()->ReadEntry(url, &metadata));
 337   EXPECT_EQ(SYNC_DATABASE_ERROR_NOT_FOUND, DeleteEntry(url));
 338
 339   VerifyReverseMap();
 340 }
 341
 342 void DriveMetadataStoreTest::GetConflictURLs_Body() {
 343   InitializeDatabase();
 344
 345   fileapi::FileSystemURLSet urls;
 346   EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetConflictURLs(&urls));
 347   EXPECT_EQ(0U, urls.size());
 348
 349   const base::FilePath path1(FPL("file1"));
 350   const base::FilePath path2(FPL("file2"));
 351   const base::FilePath path3(FPL("file3"));
 352
 353   // Populate metadata in DriveMetadataStore. The metadata identified by "file2"
 354   // and "file3" are marked as conflicted.
 355   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 356       URL(path1),
 357       CreateMetadata("file:1", "1", false, false,
 358                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 359   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 360       URL(path2),
 361       CreateMetadata("file:2", "2", true, false,
 362                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 363   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 364       URL(path3),
 365       CreateMetadata("file:3", "3", true, false,
 366                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 367
 368   EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetConflictURLs(&urls));
 369   EXPECT_EQ(2U, urls.size());
 370   EXPECT_FALSE(ContainsKey(urls, URL(path1)));
 371   EXPECT_TRUE(ContainsKey(urls, URL(path2)));
 372   EXPECT_TRUE(ContainsKey(urls, URL(path3)));
 373
 374   VerifyReverseMap();
 375 }
 376
 377 void DriveMetadataStoreTest::GetToBeFetchedFiles_Body() {
 378   InitializeDatabase();
 379
 380   DriveMetadataStore::URLAndDriveMetadataList list;
 381   EXPECT_EQ(SYNC_STATUS_OK, metadata_store()->GetToBeFetchedFiles(&list));
 382   EXPECT_TRUE(list.empty());
 383
 384   const base::FilePath path1(FPL("file1"));
 385   const base::FilePath path2(FPL("file2"));
 386   const base::FilePath path3(FPL("file3"));
 387
 388   // Populate metadata in DriveMetadataStore. The metadata identified by "file2"
 389   // and "file3" are marked to be fetched.
 390   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 391       URL(path1),
 392       CreateMetadata("file:1", "1", false, false,
 393                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 394   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 395       URL(path2),
 396       CreateMetadata("file:2", "2", false, true,
 397                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 398   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 399       URL(path3),
 400       CreateMetadata("file:3", "3", false, true,
 401                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 402
 403   EXPECT_EQ(SYNC_STATUS_OK,
 404             metadata_store()->GetToBeFetchedFiles(&list));
 405   EXPECT_EQ(2U, list.size());
 406   EXPECT_EQ(list[0].first, URL(path2));
 407   EXPECT_EQ(list[1].first, URL(path3));
 408
 409   VerifyReverseMap();
 410 }
 411
 412 void DriveMetadataStoreTest::StoreSyncRootDirectory_Body() {
 413   const std::string kResourceId(CreateResourceId("folder:hoge"));
 414
 415   InitializeDatabase();
 416   EXPECT_TRUE(metadata_store()->sync_root_directory().empty());
 417
 418   metadata_store()->SetSyncRootDirectory(kResourceId);
 419   EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory());
 420
 421   DropDatabase();
 422   InitializeDatabase();
 423   EXPECT_EQ(kResourceId, metadata_store()->sync_root_directory());
 424 }
 425
 426 void DriveMetadataStoreTest::StoreSyncOrigin_Body() {
 427   const GURL kOrigin1("chrome-extension://example1");
 428   const GURL kOrigin2("chrome-extension://example2");
 429   const std::string kResourceId1(CreateResourceId("folder:hoge"));
 430   const std::string kResourceId2(CreateResourceId("folder:fuga"));
 431
 432   InitializeDatabase();
 433
 434   // Make sure origins have not been marked yet.
 435   VerifyUntrackedOrigin(kOrigin1);
 436   VerifyUntrackedOrigin(kOrigin2);
 437
 438   // Mark origins as incremental sync origins.
 439   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
 440   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
 441   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
 442   VerifyIncrementalSyncOrigin(kOrigin2, kResourceId2);
 443
 444   // Disabled origin 2, origin 1 should still be incremental.
 445   DisableOrigin(kOrigin2);
 446   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
 447   VerifyDisabledOrigin(kOrigin2, kResourceId2);
 448
 449   DropDatabase();
 450   InitializeDatabase();
 451
 452   // Make sure origins have been restored.
 453   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
 454   VerifyDisabledOrigin(kOrigin2, kResourceId2);
 455
 456   VerifyReverseMap();
 457 }
 458
 459 void DriveMetadataStoreTest::DisableOrigin_Body() {
 460   const GURL kOrigin1("chrome-extension://example1");
 461   const std::string kResourceId1(CreateResourceId("folder:hoge"));
 462
 463   InitializeDatabase();
 464   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 465
 466   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
 467   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
 468
 469   DisableOrigin(kOrigin1);
 470   VerifyDisabledOrigin(kOrigin1, kResourceId1);
 471
 472   // Re-enabled origins go back to DriveFileSyncService and are not tracked
 473   // in DriveMetadataStore.
 474   EnableOrigin(kOrigin1);
 475   VerifyUntrackedOrigin(kOrigin1);
 476 }
 477
 478 void DriveMetadataStoreTest::RemoveOrigin_Body() {
 479   const GURL kOrigin1("chrome-extension://example1");
 480   const GURL kOrigin2("chrome-extension://example2");
 481   const GURL kOrigin3("chrome-extension://example3");
 482   const std::string kResourceId1(CreateResourceId("folder:hogera"));
 483   const std::string kResourceId2(CreateResourceId("folder:fugaga"));
 484   const std::string kResourceId3(CreateResourceId("folder:piyopiyo"));
 485
 486   InitializeDatabase();
 487   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 488
 489   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
 490   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
 491   metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3);
 492   DisableOrigin(kOrigin3);
 493   EXPECT_EQ(2u, metadata_store()->incremental_sync_origins().size());
 494   EXPECT_EQ(1u, metadata_store()->disabled_origins().size());
 495
 496   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 497       CreateSyncableFileSystemURL(kOrigin1, base::FilePath(FPL("guf"))),
 498       CreateMetadata("file:foo", "spam", false, false,
 499                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 500   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 501       CreateSyncableFileSystemURL(kOrigin2, base::FilePath(FPL("mof"))),
 502       CreateMetadata("file:bar", "ham", false, false,
 503                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 504   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 505       CreateSyncableFileSystemURL(kOrigin3, base::FilePath(FPL("waf"))),
 506       CreateMetadata("folder:baz", "egg", false, false,
 507                      DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER)));
 508
 509   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin2));
 510   EXPECT_EQ(SYNC_STATUS_OK, RemoveOrigin(kOrigin3));
 511
 512   DropDatabase();
 513   InitializeDatabase();
 514
 515   // kOrigin1 should be the only one left.
 516   EXPECT_EQ(1u, metadata_store()->incremental_sync_origins().size());
 517   EXPECT_EQ(0u, metadata_store()->disabled_origins().size());
 518   EXPECT_TRUE(metadata_store()->IsIncrementalSyncOrigin(kOrigin1));
 519   EXPECT_EQ(1u, metadata_map().size());
 520
 521   DriveMetadataStore::MetadataMap::const_iterator found =
 522       metadata_map().find(kOrigin1);
 523   EXPECT_TRUE(found != metadata_map().end() && found->second.size() == 1u);
 524
 525   VerifyReverseMap();
 526 }
 527
 528 void DriveMetadataStoreTest::GetResourceIdForOrigin_Body() {
 529   const GURL kOrigin1("chrome-extension://example1");
 530   const GURL kOrigin2("chrome-extension://example2");
 531   const GURL kOrigin3("chrome-extension://example3");
 532   const std::string kResourceId1(CreateResourceId("folder:hogera"));
 533   const std::string kResourceId2(CreateResourceId("folder:fugaga"));
 534   const std::string kResourceId3(CreateResourceId("folder:piyopiyo"));
 535
 536   InitializeDatabase();
 537   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 538   metadata_store()->SetSyncRootDirectory(CreateResourceId("folder:root"));
 539
 540   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
 541   metadata_store()->AddIncrementalSyncOrigin(kOrigin2, kResourceId2);
 542   metadata_store()->AddIncrementalSyncOrigin(kOrigin3, kResourceId3);
 543   DisableOrigin(kOrigin3);
 544
 545   EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1));
 546   EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2));
 547   EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3));
 548
 549   DropDatabase();
 550   InitializeDatabase();
 551
 552   EXPECT_EQ(kResourceId1, metadata_store()->GetResourceIdForOrigin(kOrigin1));
 553   EXPECT_EQ(kResourceId2, metadata_store()->GetResourceIdForOrigin(kOrigin2));
 554   EXPECT_EQ(kResourceId3, metadata_store()->GetResourceIdForOrigin(kOrigin3));
 555
 556   // Resetting the root directory resource ID to empty makes any
 557   // GetResourceIdForOrigin return an empty resource ID too, regardless of
 558   // whether they are known origin or not.
 559   metadata_store()->SetSyncRootDirectory(std::string());
 560   EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin1).empty());
 561   EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin2).empty());
 562   EXPECT_TRUE(metadata_store()->GetResourceIdForOrigin(kOrigin3).empty());
 563
 564   // Make sure they're still known origins.
 565   EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin1));
 566   EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin2));
 567   EXPECT_TRUE(metadata_store()->IsKnownOrigin(kOrigin3));
 568
 569   VerifyReverseMap();
 570 }
 571
 572 void DriveMetadataStoreTest::ResetOriginRootDirectory_Body() {
 573   const GURL kOrigin1("chrome-extension://example1");
 574   const std::string kResourceId1(CreateResourceId("folder:hoge"));
 575   const std::string kResourceId2(CreateResourceId("folder:fuga"));
 576
 577   InitializeDatabase();
 578   EXPECT_EQ(SYNC_STATUS_OK, SetLargestChangeStamp(1));
 579
 580   metadata_store()->AddIncrementalSyncOrigin(kOrigin1, kResourceId1);
 581   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId1);
 582   VerifyReverseMap();
 583
 584   metadata_store()->SetOriginRootDirectory(kOrigin1, kResourceId2);
 585   VerifyIncrementalSyncOrigin(kOrigin1, kResourceId2);
 586   VerifyReverseMap();
 587 }
 588
 589 void DriveMetadataStoreTest::GetFileMetadataMap_Body() {
 590   InitializeDatabase();
 591
 592   // Save one file and folder to the origin.
 593   const base::FilePath file_path = base::FilePath(FPL("file_0"));
 594   const base::FilePath folder_path = base::FilePath(FPL("folder_0"));
 595
 596   const GURL origin = GURL("chrome-extension://app_a");
 597   const fileapi::FileSystemURL url_0 = CreateSyncableFileSystemURL(
 598       origin, file_path);
 599   const fileapi::FileSystemURL url_1 = CreateSyncableFileSystemURL(
 600       origin, folder_path);
 601
 602   // Insert DrivaMetadata objects.
 603   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 604       url_0,
 605       CreateMetadata("file:0", "1", false, false,
 606                      DriveMetadata_ResourceType_RESOURCE_TYPE_FILE)));
 607   EXPECT_EQ(SYNC_STATUS_OK, UpdateEntry(
 608       url_1,
 609       CreateMetadata("folder:0", "2", false, true,
 610                      DriveMetadata_ResourceType_RESOURCE_TYPE_FOLDER)));
 611
 612   // Check that DriveMetadata objects get mapped back to generalized
 613   // FileMetadata objects.
 614   scoped_ptr<base::ListValue> files = metadata_store()->DumpFiles(origin);
 615   ASSERT_EQ(2u, files->GetSize());
 616
 617   base::DictionaryValue* file = NULL;
 618   std::string str;
 619
 620   ASSERT_TRUE(files->GetDictionary(0, &file));
 621   EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
 622   EXPECT_TRUE(file->GetString("type", &str) && str == "file");
 623   EXPECT_TRUE(file->HasKey("details"));
 624
 625   ASSERT_TRUE(files->GetDictionary(1, &file));
 626   EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0");
 627   EXPECT_TRUE(file->GetString("type", &str) && str == "folder");
 628   EXPECT_TRUE(file->HasKey("details"));
 629 }
 630
 631 TEST_F(DriveMetadataStoreTest, Initialization) {
 632   ASSERT_FALSE(IsDriveAPIDisabled());
 633   InitializeDatabase();
 634 }
 635
 636 TEST_F(DriveMetadataStoreTest, Initialization_WAPI) {
 637   SetDisableDriveAPI(true);
 638   InitializeDatabase();
 639 }
 640
 641 TEST_F(DriveMetadataStoreTest, ReadWrite) {
 642   ASSERT_FALSE(IsDriveAPIDisabled());
 643   ReadWrite_Body();
 644 }
 645
 646 TEST_F(DriveMetadataStoreTest, ReadWrite_WAPI) {
 647   SetDisableDriveAPI(true);
 648   ReadWrite_Body();
 649 }
 650
 651 TEST_F(DriveMetadataStoreTest, GetConflictURLs) {
 652   ASSERT_FALSE(IsDriveAPIDisabled());
 653   GetConflictURLs_Body();
 654 }
 655
 656 TEST_F(DriveMetadataStoreTest, GetConflictURLs_WAPI) {
 657   SetDisableDriveAPI(true);
 658   GetConflictURLs_Body();
 659 }
 660
 661 TEST_F(DriveMetadataStoreTest, GetToBeFetchedFiles) {
 662   ASSERT_FALSE(IsDriveAPIDisabled());
 663   GetToBeFetchedFiles_Body();
 664 }
 665
 666 TEST_F(DriveMetadataStoreTest, GetToBeFetchedFiles_WAPI) {
 667   SetDisableDriveAPI(true);
 668   GetToBeFetchedFiles_Body();
 669 }
 670
 671 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory) {
 672   ASSERT_FALSE(IsDriveAPIDisabled());
 673   StoreSyncRootDirectory_Body();
 674 }
 675
 676 TEST_F(DriveMetadataStoreTest, StoreSyncRootDirectory_WAPI) {
 677   SetDisableDriveAPI(true);
 678   StoreSyncRootDirectory_Body();
 679 }
 680
 681 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin) {
 682   ASSERT_FALSE(IsDriveAPIDisabled());
 683   StoreSyncOrigin_Body();
 684 }
 685
 686 TEST_F(DriveMetadataStoreTest, StoreSyncOrigin_WAPI) {
 687   SetDisableDriveAPI(true);
 688   StoreSyncOrigin_Body();
 689 }
 690
 691 TEST_F(DriveMetadataStoreTest, DisableOrigin) {
 692   ASSERT_FALSE(IsDriveAPIDisabled());
 693   DisableOrigin_Body();
 694 }
 695
 696 TEST_F(DriveMetadataStoreTest, DisableOrigin_WAPI) {
 697   SetDisableDriveAPI(true);
 698   DisableOrigin_Body();
 699 }
 700
 701 TEST_F(DriveMetadataStoreTest, RemoveOrigin) {
 702   ASSERT_FALSE(IsDriveAPIDisabled());
 703   RemoveOrigin_Body();
 704 }
 705
 706 TEST_F(DriveMetadataStoreTest, RemoveOrigin_WAPI) {
 707   SetDisableDriveAPI(true);
 708   RemoveOrigin_Body();
 709 }
 710
 711 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin) {
 712   ASSERT_FALSE(IsDriveAPIDisabled());
 713   GetResourceIdForOrigin_Body();
 714 }
 715
 716 TEST_F(DriveMetadataStoreTest, GetResourceIdForOrigin_WAPI) {
 717   SetDisableDriveAPI(true);
 718   GetResourceIdForOrigin_Body();
 719 }
 720
 721 TEST_F(DriveMetadataStoreTest, ResetOriginRootDirectory) {
 722   ASSERT_FALSE(IsDriveAPIDisabled());
 723   ResetOriginRootDirectory_Body();
 724 }
 725
 726 TEST_F(DriveMetadataStoreTest, ResetOriginRootDirectory_WAPI) {
 727   SetDisableDriveAPI(true);
 728   ResetOriginRootDirectory_Body();
 729 }
 730
 731 TEST_F(DriveMetadataStoreTest, GetFileMetadataMap) {
 732   ASSERT_FALSE(IsDriveAPIDisabled());
 733   GetFileMetadataMap_Body();
 734 }
 735
 736 TEST_F(DriveMetadataStoreTest, GetFileMetadataMap_WAPI) {
 737   SetDisableDriveAPI(true);
 738   GetFileMetadataMap_Body();
 739 }
 740
 741 }  // namespace sync_file_system