crashpad_database_util: Don’t create a database unless explicitly asked

client/crash_report_database_mac.mm

 // 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 45 matching lines @@
 
 const char kXattrUUID[] = "uuid";
 const char kXattrCollectorID[] = "id";
 const char kXattrCreationTime[] = "creation_time";
 const char kXattrIsUploaded[] = "uploaded";
 const char kXattrLastUploadTime[] = "last_upload_time";
 const char kXattrUploadAttemptCount[] = "upload_count";
 
 const char kXattrDatabaseInitialized[] = "initialized";
 
+// Ensures that the node at |path| is a directory. If the |path| refers to a
+// file, rather than a directory, returns false. Otherwise, returns true,
+// indicating that |path| already was a directory.
+bool EnsureDirectoryExists(const base::FilePath& path) {
+  struct stat st;
+  if (stat(path.value().c_str(), &st) != 0) {
+    PLOG(ERROR) << "stat " << path.value();
+    return false;
+  }
+  if (S_ISDIR(st.st_mode)) {
+    return true;
+  }
+  LOG(ERROR) << "stat " << path.value() << ": not a directory";
+  return false;
+}
+
 // Ensures that the node at |path| is a directory, and creates it if it does
-// not exist. If the |path| points to a file, rather than a directory, or the
+// not exist. If the |path| refers to a file, rather than a directory, or the
 // directory could not be created, returns false. Otherwise, returns true,
 // indicating that |path| already was or now is a directory.
 bool CreateOrEnsureDirectoryExists(const base::FilePath& path) {
   if (mkdir(path.value().c_str(), 0755) == 0) {
     return true;
-  } else if (errno == EEXIST) {
-    struct stat st;
-    if (stat(path.value().c_str(), &st) != 0) {
-      PLOG(ERROR) << "stat";
-      return false;
-    }
-    if (S_ISDIR(st.st_mode)) {
-      return true;
-    } else {
-      LOG(ERROR) << "not a directory";
-      return false;
-    }
-  } else {
-    PLOG(ERROR) << "mkdir";
+  }
+  if (errno != EEXIST) {
+    PLOG(ERROR) << "mkdir " << path.value();
     return false;
   }
+  return EnsureDirectoryExists(path);
 }
 
 //! \brief A CrashReportDatabase that uses HFS+ extended attributes to store
 //!     report metadata.
 //!
 //! The database maintains three directories of reports: `"new"` to hold crash
 //! reports that are in the process of being written, `"completed"` to hold
 //! reports that have been written and are awaiting upload, and `"uploaded"` to
 //! hold reports successfully uploaded to a collection server. If the user has
 //! opted out of report collection, reports will still be written and moved
 //! to the completed directory, but they just will not be uploaded.
 //!
 //! The database stores its metadata in extended filesystem attributes. To
 //! ensure safe access, the report file is locked using `O_EXLOCK` during all
 //! extended attribute operations. The lock should be obtained using
 //! ObtainReportLock().
 class CrashReportDatabaseMac : public CrashReportDatabase {
  public:
   explicit CrashReportDatabaseMac(const base::FilePath& path);
   virtual ~CrashReportDatabaseMac();
 
-  bool Initialize();
+  bool Initialize(bool create);
 
   // CrashReportDatabase:
   Settings* GetSettings() override;
   OperationStatus PrepareNewCrashReport(NewReport** report) override;
   OperationStatus FinishedWritingCrashReport(NewReport* report,
                                              UUID* uuid) override;
   OperationStatus ErrorWritingCrashReport(NewReport* report) override;
-  OperationStatus LookUpCrashReport(const UUID& uuid,
-                                    Report* report) override;
+  OperationStatus LookUpCrashReport(const UUID& uuid, Report* report) override;
   OperationStatus GetPendingReports(std::vector<Report>* reports) override;
   OperationStatus GetCompletedReports(std::vector<Report>* reports) override;
   OperationStatus GetReportForUploading(const UUID& uuid,
                                         const Report** report) override;
   OperationStatus RecordUploadAttempt(const Report* report,
                                       bool successful,
                                       const std::string& id) override;
   OperationStatus SkipReportUpload(const UUID& uuid) override;
 
  private:
@@ skipping 43 matching lines @@
   //! \brief Reads the metadata from all the reports in a database subdirectory.
   //!      Invalid reports are skipped.
   //!
   //! \param[in] path The database subdirectory path.
   //! \param[out] reports An empty vector of reports, which will be filled.
   //!
   //! \return The operation status code.
   static OperationStatus ReportsInDirectory(const base::FilePath& path,
                                             std::vector<Report>* reports);
 
-
   //! \brief Creates a database xattr name from the short constant name.
   //!
   //! \param[in] name The short name of the extended attribute.
   //!
   //! \return The long name of the extended attribute.
   static std::string XattrName(const base::StringPiece& name);
 
   base::FilePath base_dir_;
   Settings settings_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseMac);
 };
 
 CrashReportDatabaseMac::CrashReportDatabaseMac(const base::FilePath& path)
     : CrashReportDatabase(),
       base_dir_(path),
       settings_(base_dir_.Append(kSettings)),
       initialized_() {
 }
 
 CrashReportDatabaseMac::~CrashReportDatabaseMac() {}
 
-bool CrashReportDatabaseMac::Initialize() {
+bool CrashReportDatabaseMac::Initialize(bool create) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
   // Check if the database already exists.
-  if (!CreateOrEnsureDirectoryExists(base_dir_))
+  if (create) {
+    if (!CreateOrEnsureDirectoryExists(base_dir_)) {
+      return false;
+    }
+  } else if (!EnsureDirectoryExists(base_dir_)) {
     return false;
+  }
 
   // Create the three processing directories for the database.
   for (size_t i = 0; i < arraysize(kReportDirectories); ++i) {
     if (!CreateOrEnsureDirectoryExists(base_dir_.Append(kReportDirectories[i])))
       return false;
   }
 
   if (!settings_.Initialize())
     return false;
 
@@ skipping 250 matching lines @@
     return kFileSystemError;
   }
 
   return kNoError;
 }
 
 base::FilePath CrashReportDatabaseMac::LocateCrashReport(const UUID& uuid) {
   const std::string target_uuid = uuid.ToString();
   for (size_t i = 0; i < arraysize(kReportDirectories); ++i) {
     base::FilePath path =
-       base_dir_.Append(kReportDirectories[i])
-                .Append(target_uuid + "." + kCrashReportFileExtension);
+        base_dir_.Append(kReportDirectories[i])
+                 .Append(target_uuid + "." + kCrashReportFileExtension);
 
     // Test if the path exists.
     struct stat st;
     if (lstat(path.value().c_str(), &st)) {
       continue;
     }
 
     // Check that the UUID of the report matches.
     std::string uuid_string;
     if (ReadXattr(path, XattrName(kXattrUUID),
@@ skipping 97 matching lines @@
 
 // static
 std::string CrashReportDatabaseMac::XattrName(const base::StringPiece& name) {
   return base::StringPrintf("com.googlecode.crashpad.%s", name.data());
 }
 
 }  // namespace
 
 // static
 scoped_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
-    const base::FilePath& path) {
+    const base::FilePath& path, bool create) {
   scoped_ptr<CrashReportDatabaseMac> database_mac(
       new CrashReportDatabaseMac(path));
-  if (!database_mac->Initialize())
+  if (!database_mac->Initialize(create))
     database_mac.reset();
 
   return scoped_ptr<CrashReportDatabase>(database_mac.release());
 }
 
 }  // namespace crashpad