Define the Settings interface for a CrashReportDatabase and provide a Mac implementation.

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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "client/crash_report_database.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #import <Foundation/Foundation.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <uuid/uuid.h>
 
 #include "base/logging.h"
+#include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/scoped_generic.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
+#include "client/settings.h"
 #include "util/file/file_io.h"
 #include "util/mac/xattr.h"
 
 namespace crashpad {
 
 namespace {
 
 const char kDatabaseDirectoryName[] = "Crashpad";
 
 const char kWriteDirectory[] = "new";
 const char kUploadPendingDirectory[] = "pending";
 const char kCompletedDirectory[] = "completed";
 
+const char kSettings[] = "settings.dat";
+
 const char* const kReportDirectories[] = {
   kWriteDirectory,
   kUploadPendingDirectory,
   kCompletedDirectory,
 };
 
 const char kCrashReportFileExtension[] = "dmp";
 
 const char kXattrUUID[] = "uuid";
 const char kXattrCollectorID[] = "id";
@@ skipping 44 matching lines @@
 //! 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();
 
   // 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<const Report>* reports) override;
   OperationStatus GetCompletedReports(
       std::vector<const Report>* reports) override;
@@ skipping 60 matching lines @@
 
 
   //! \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_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseMac);
 };
 
 CrashReportDatabaseMac::CrashReportDatabaseMac(const base::FilePath& path)
-    : CrashReportDatabase(), base_dir_(path) {
+    : CrashReportDatabase(),
+      base_dir_(path),
+      settings_(base_dir_.Append(kSettings)) {
 }
 
 CrashReportDatabaseMac::~CrashReportDatabaseMac() {}
 
 bool CrashReportDatabaseMac::Initialize() {

[Mark Mentovai, 2015/03/09 19:12:35]

An InitializationStateDcheck could help here. That’s OK for a distinct change.

   // Check if the database already exists.
   if (!CreateOrEnsureDirectoryExists(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;
+
   // Write an xattr as the last step, to ensure the filesystem has support for
   // them. This attribute will never be read.
   return WriteXattrBool(base_dir_, XattrName(kXattrDatabaseInitialized), true);
 }
 
+Settings* CrashReportDatabaseMac::GetSettings() {
+  return &settings_;
+}
+
 CrashReportDatabase::OperationStatus
 CrashReportDatabaseMac::PrepareNewCrashReport(NewReport** out_report) {
   uuid_t uuid_gen;
   uuid_generate(uuid_gen);
   UUID uuid(uuid_gen);
 
   scoped_ptr<NewReport> report(new NewReport());
 
   report->path =
       base_dir_.Append(kWriteDirectory)
@@ skipping 275 matching lines @@
     return false;
   }
 
   return true;
 }
 
 // static
 CrashReportDatabase::OperationStatus CrashReportDatabaseMac::ReportsInDirectory(
     const base::FilePath& path,
     std::vector<const CrashReportDatabase::Report>* reports) {
+  base::mac::ScopedNSAutoreleasePool pool;
+
   DCHECK(reports->empty());
 
   NSError* error = nil;
   NSArray* paths = [[NSFileManager defaultManager]
       contentsOfDirectoryAtPath:base::SysUTF8ToNSString(path.value())
                           error:&error];
   if (error) {
     LOG(ERROR) << "Failed to enumerate reports in directory " << path.value()
                << ": " << [[error description] UTF8String];
     return kFileSystemError;
@@ skipping 30 matching lines @@
     const base::FilePath& path) {
   scoped_ptr<CrashReportDatabaseMac> database_mac(
       new CrashReportDatabaseMac(path.Append(kDatabaseDirectoryName)));
   if (!database_mac->Initialize())
     database_mac.reset();
 
   return scoped_ptr<CrashReportDatabase>(database_mac.release());
 }
 
 }  // namespace crashpad