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