crashpad_database_util: Don’t create a database unless explicitly asked

client/crash_report_database_win.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 465 matching lines @@
 }
 
 // static
 OperationStatus Metadata::VerifyReport(const ReportDisk& report_disk,
                                        ReportState desired_state) {
   return (report_disk.state == desired_state)
              ? VerifyReportAnyState(report_disk)
              : CrashReportDatabase::kBusyError;
 }
 
+bool EnsureDirectory(const base::FilePath& path) {
+  DWORD fileattr = GetFileAttributes(path.value().c_str());
+  if (fileattr == INVALID_FILE_ATTRIBUTES) {
+    PLOG(ERROR) << "GetFileAttributes " << base::UTF16ToUTF8(path.value());
+    return false;
+  }
+  if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
+    LOG(ERROR) << "GetFileAttributes "
+               << base::UTF16ToUTF8(path.value())
+               << ": not a directory";
+    return false;
+  }
+  return true;
+}
+
 //! \brief Ensures that the node at path is a directory, and creates it if it
 //!     does not exist.
 //!
 //! \return If the path points 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 CreateDirectoryIfNecessary(const base::FilePath& path) {
   if (CreateDirectory(path.value().c_str(), nullptr))
     return true;
   if (GetLastError() != ERROR_ALREADY_EXISTS) {
-    PLOG(ERROR) << "CreateDirectory";
+    PLOG(ERROR) << "CreateDirectory " << base::UTF16ToUTF8(path.value());
     return false;
   }
-  DWORD fileattr = GetFileAttributes(path.value().c_str());
-  if (fileattr == INVALID_FILE_ATTRIBUTES) {
-    PLOG(ERROR) << "GetFileAttributes";
-    return false;
-  }
-  if ((fileattr & FILE_ATTRIBUTE_DIRECTORY) != 0)
-    return true;
-  LOG(ERROR) << "not a directory";
-  return false;
+  return EnsureDirectory(path);
 }
 
 // CrashReportDatabaseWin ------------------------------------------------------
 
 class CrashReportDatabaseWin : public CrashReportDatabase {
  public:
   explicit CrashReportDatabaseWin(const base::FilePath& path);
   ~CrashReportDatabaseWin() override;
 
-  bool Initialize();
+  bool Initialize(bool may_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 GetPendingReports(std::vector<Report>* reports) override;
   OperationStatus GetCompletedReports(std::vector<Report>* reports) override;
@@ skipping 17 matching lines @@
 CrashReportDatabaseWin::CrashReportDatabaseWin(const base::FilePath& path)
     : CrashReportDatabase(),
       base_dir_(path),
       settings_(base_dir_.Append(kSettings)),
       initialized_() {
 }
 
 CrashReportDatabaseWin::~CrashReportDatabaseWin() {
 }
 
-bool CrashReportDatabaseWin::Initialize() {
+bool CrashReportDatabaseWin::Initialize(bool may_create) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
-  // Ensure the database and report subdirectories exist.
-  if (!CreateDirectoryIfNecessary(base_dir_) ||
-      !CreateDirectoryIfNecessary(base_dir_.Append(kReportsDirectory)))
+  // Ensure the databse directory exists.

[scottmg, 2015/10/07 20:58:18]

'database' if you didn't already land.

[Mark Mentovai, 2015/10/07 21:03:34]

scottmg wrote:
Fixed.

Seriously, I think Atom eats keystrokes. Must be because it’s Chromium-based. :(

+  if (may_create) {
+    if (!CreateDirectoryIfNecessary(base_dir_))
+      return false;
+  } else if (!EnsureDirectory(base_dir_)) {
+    return false;
+  }
+
+  // Ensure that the report subdirectory exists.
+  if (!CreateDirectoryIfNecessary(base_dir_.Append(kReportsDirectory)))
     return false;
 
   // TODO(scottmg): When are completed reports pruned from disk? Delete here or
   // maybe on AcquireMetadata().
 
   if (!settings_.Initialize())
     return false;
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
@@ skipping 173 matching lines @@
   if (os == kNoError)
     report_disk->state = ReportState::kCompleted;
   return os;
 }
 
 scoped_ptr<Metadata> CrashReportDatabaseWin::AcquireMetadata() {
   base::FilePath metadata_file = base_dir_.Append(kMetadataFileName);
   return Metadata::Create(metadata_file, base_dir_.Append(kReportsDirectory));
 }
 
+scoped_ptr<CrashReportDatabase> InitializeInternal(
+    const base::FilePath& path, bool may_create) {
+  scoped_ptr<CrashReportDatabaseWin> database_win(
+      new CrashReportDatabaseWin(path));
+  return database_win->Initialize(may_create)
+      ? database_win.Pass() : scoped_ptr<CrashReportDatabaseWin>();

[Robert Sesek, 2015/10/07 21:04:33]

nit: shouldn't ? go on the previous line?

[Mark Mentovai, 2015/10/07 21:07:09]

Robert Sesek wrote:
Updated to what clang-format likes here, which is actually a third option.

+}
+
 }  // namespace
 
 // static
 scoped_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
     const base::FilePath& path) {
-  scoped_ptr<CrashReportDatabaseWin> database_win(
-      new CrashReportDatabaseWin(path));
-  return database_win->Initialize() ? database_win.Pass()
-                                    : scoped_ptr<CrashReportDatabaseWin>();
+  return InitializeInternal(path, true);
+}
+
+// static
+scoped_ptr<CrashReportDatabase> CrashReportDatabase::InitializeWithoutCreating(
+    const base::FilePath& path) {
+  return InitializeInternal(path, false);
 }
 
 }  // namespace crashpad