crashpad_database_util: Don’t create a database unless explicitly asked

client/crash_report_database_test.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 16 matching lines @@
 namespace {
 
 class CrashReportDatabaseTest : public testing::Test {
  public:
   CrashReportDatabaseTest() {
   }
 
  protected:
   // testing::Test:
   void SetUp() override {
-    db_ = CrashReportDatabase::Initialize(path());
+    db_ = CrashReportDatabase::Initialize(path(), true);
     ASSERT_TRUE(db_);
   }
 
   void ResetDatabase() {
     db_.reset();
   }
 
   CrashReportDatabase* db() { return db_.get(); }
   base::FilePath path() const {
     return temp_dir_.path().Append(FILE_PATH_LITERAL("crashpad_test_database"));
@@ skipping 20 matching lines @@
     Settings* const settings = db_->GetSettings();
     ASSERT_TRUE(settings);
     time_t times[2];
     ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[0]));
 
     const CrashReportDatabase::Report* report = nullptr;
     ASSERT_EQ(CrashReportDatabase::kNoError,
               db_->GetReportForUploading(uuid, &report));
     EXPECT_NE(UUID(), report->uuid);
     EXPECT_FALSE(report->file_path.empty());
-    EXPECT_TRUE(FileExists(report->file_path))
-        << report->file_path.value();
+    EXPECT_TRUE(FileExists(report->file_path)) << report->file_path.value();
     EXPECT_GT(report->creation_time, 0);
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->RecordUploadAttempt(report, successful, id));
 
     ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[1]));
     EXPECT_NE(times[1], 0);
     EXPECT_GE(times[1], times[0]);
   }
 
   void ExpectPreparedCrashReport(const CrashReportDatabase::Report& report) {
@@ skipping 19 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseTest);
 };
 
 TEST_F(CrashReportDatabaseTest, Initialize) {
   // Initialize the database for the first time, creating it.
   ASSERT_TRUE(db());
 
   Settings* settings = db()->GetSettings();
 
-  UUID client_ids[2];
+  UUID client_ids[3];
   ASSERT_TRUE(settings->GetClientID(&client_ids[0]));
   EXPECT_NE(client_ids[0], UUID());
 
   time_t last_upload_attempt_time;
   ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
   EXPECT_EQ(0, last_upload_attempt_time);
 
   // Close and reopen the database at the same path.
   ResetDatabase();
   EXPECT_FALSE(db());
-  auto db = CrashReportDatabase::Initialize(path());
+  auto db = CrashReportDatabase::Initialize(path(), false);
   ASSERT_TRUE(db);
 
   settings = db->GetSettings();
 
   ASSERT_TRUE(settings->GetClientID(&client_ids[1]));
   EXPECT_EQ(client_ids[0], client_ids[1]);
 
   ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
   EXPECT_EQ(0, last_upload_attempt_time);
 
+  // Check that the database can also be opened when “create” is set to true.
+  db = CrashReportDatabase::Initialize(path(), true);
+  ASSERT_TRUE(db);
+
+  settings = db->GetSettings();
+
+  ASSERT_TRUE(settings->GetClientID(&client_ids[2]));
+  EXPECT_EQ(client_ids[0], client_ids[2]);
+
+  ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
+  EXPECT_EQ(0, last_upload_attempt_time);
+
   std::vector<CrashReportDatabase::Report> reports;
   EXPECT_EQ(CrashReportDatabase::kNoError, db->GetPendingReports(&reports));
   EXPECT_TRUE(reports.empty());
   reports.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError, db->GetCompletedReports(&reports));
   EXPECT_TRUE(reports.empty());
+
+  // With “create” set to false, a nonexistent database shouldn’t be created.
+  base::FilePath non_database_path =
+      path().DirName().Append(FILE_PATH_LITERAL("not_a_database"));
+  db = CrashReportDatabase::Initialize(non_database_path, false);
+  EXPECT_FALSE(db);
 }
 
 TEST_F(CrashReportDatabaseTest, NewCrashReport) {
   CrashReportDatabase::NewReport* new_report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->PrepareNewCrashReport(&new_report));
   UUID expect_uuid = new_report->uuid;
   EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
   UUID uuid;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->FinishedWritingCrashReport(new_report, &uuid));
   EXPECT_EQ(expect_uuid, uuid);
 
   CrashReportDatabase::Report report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->LookUpCrashReport(uuid, &report));
   ExpectPreparedCrashReport(report);
 
   std::vector<CrashReportDatabase::Report> reports;
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&reports));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&reports));
   ASSERT_EQ(1u, reports.size());
   EXPECT_EQ(report.uuid, reports[0].uuid);
 
   reports.clear();
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetCompletedReports(&reports));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetCompletedReports(&reports));
   EXPECT_TRUE(reports.empty());
 }
 
 TEST_F(CrashReportDatabaseTest, ErrorWritingCrashReport) {
   CrashReportDatabase::NewReport* new_report = nullptr;
   ASSERT_EQ(CrashReportDatabase::kNoError,
             db()->PrepareNewCrashReport(&new_report));
   base::FilePath new_report_path = new_report->path;
   EXPECT_TRUE(FileExists(new_report_path)) << new_report_path.value();
   EXPECT_EQ(CrashReportDatabase::kNoError,
@@ skipping 129 matching lines @@
   CreateCrashReport(&reports[3]);
   CreateCrashReport(&reports[4]);
 
   const UUID& report_0_uuid = reports[0].uuid;
   const UUID& report_1_uuid = reports[1].uuid;
   const UUID& report_2_uuid = reports[2].uuid;
   const UUID& report_3_uuid = reports[3].uuid;
   const UUID& report_4_uuid = reports[4].uuid;
 
   std::vector<CrashReportDatabase::Report> pending;
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&pending));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&pending));
 
   std::vector<CrashReportDatabase::Report> completed;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&completed));
 
   EXPECT_EQ(reports.size(), pending.size());
   EXPECT_EQ(0u, completed.size());
 
   // Upload one report successfully.
   UploadReport(report_1_uuid, true, "report1");
 
   pending.clear();
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&pending));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&pending));
   completed.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&completed));
 
   EXPECT_EQ(4u, pending.size());
   ASSERT_EQ(1u, completed.size());
 
   for (const auto& report : pending) {
     EXPECT_NE(report_1_uuid, report.uuid);
     EXPECT_FALSE(report.file_path.empty());
   }
   EXPECT_EQ(report_1_uuid, completed[0].uuid);
   EXPECT_EQ("report1", completed[0].id);
   EXPECT_EQ(true, completed[0].uploaded);
   EXPECT_GT(completed[0].last_upload_attempt_time, 0);
   EXPECT_EQ(1, completed[0].upload_attempts);
 
   // Fail to upload one report.
   UploadReport(report_2_uuid, false, std::string());
 
   pending.clear();
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&pending));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&pending));
   completed.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&completed));
 
   EXPECT_EQ(4u, pending.size());
   ASSERT_EQ(1u, completed.size());
 
   for (const auto& report : pending) {
     if (report.upload_attempts != 0) {
       EXPECT_EQ(report_2_uuid, report.uuid);
       EXPECT_GT(report.last_upload_attempt_time, 0);
       EXPECT_FALSE(report.uploaded);
       EXPECT_TRUE(report.id.empty());
     }
     EXPECT_FALSE(report.file_path.empty());
   }
 
   // Upload a second report.
   UploadReport(report_4_uuid, true, "report_4");
 
   pending.clear();
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&pending));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&pending));
   completed.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&completed));
 
   EXPECT_EQ(3u, pending.size());
   ASSERT_EQ(2u, completed.size());
 
   // Succeed the failed report.
   UploadReport(report_2_uuid, true, "report 2");
 
   pending.clear();
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&pending));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&pending));
   completed.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&completed));
 
   EXPECT_EQ(2u, pending.size());
   ASSERT_EQ(3u, completed.size());
 
   for (const auto& report : pending) {
-    EXPECT_TRUE(report.uuid == report_0_uuid ||
-                report.uuid == report_3_uuid);
+    EXPECT_TRUE(report.uuid == report_0_uuid || report.uuid == report_3_uuid);
     EXPECT_FALSE(report.file_path.empty());
   }
 
   // Skip upload for one report.
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->SkipReportUpload(report_3_uuid));
 
   pending.clear();
-  EXPECT_EQ(CrashReportDatabase::kNoError,
-            db()->GetPendingReports(&pending));
+  EXPECT_EQ(CrashReportDatabase::kNoError, db()->GetPendingReports(&pending));
   completed.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&completed));
 
   ASSERT_EQ(1u, pending.size());
   ASSERT_EQ(4u, completed.size());
 
   EXPECT_EQ(report_0_uuid, pending[0].uuid);
 
   for (const auto& report : completed) {
@@ skipping 65 matching lines @@
       << ErrnoMessage("unlink");
 #endif
 
   EXPECT_EQ(CrashReportDatabase::kReportNotFound,
             db()->LookUpCrashReport(uuid, &report));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad