Update all URLs to point to https://crashpad.chromium.org/

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 76 matching lines @@
   if (mkdir(path.value().c_str(), 0755) == 0) {
     return true;
   }
   if (errno != EEXIST) {
     PLOG(ERROR) << "mkdir " << path.value();
     return false;
   }
   return EnsureDirectoryExists(path);
 }
 
+// Creates a long database xattr name from the short constant name. These names
+// have changed, and new_name determines whether the returned xattr name will be
+// the old name or its new equivalent.
+std::string XattrNameInternal(const base::StringPiece& name, bool new_name) {

[Mark Mentovai, 2015/10/29 20:45:24]

This file is the only one with a code change.

+  return base::StringPrintf(new_name ? "org.chromium.crashpad.database.%s"
+                                     : "com.googlecode.crashpad.%s",
+                            name.data());
+}
+
 //! \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.
 //!
@@ skipping 59 matching lines @@
   static base::ScopedFD ObtainReportLock(const base::FilePath& path);
 
   //! \brief Reads all the database xattrs from a file into a Report. The file
   //!     must be locked with ObtainReportLock.
   //!
   //! \param[in] path The path of the report.
   //! \param[out] report The object into which data will be read.
   //!
   //! \return `true` if all the metadata was read successfully, `false`
   //!     otherwise.
-  static bool ReadReportMetadataLocked(const base::FilePath& path,
-                                       Report* report);
+  bool ReadReportMetadataLocked(const base::FilePath& path, Report* report);
 
   //! \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);
+  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);
+  std::string XattrName(const base::StringPiece& name);
 
   base::FilePath base_dir_;
   Settings settings_;
+  bool xattr_new_names_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseMac);
 };
 
 CrashReportDatabaseMac::CrashReportDatabaseMac(const base::FilePath& path)
     : CrashReportDatabase(),
       base_dir_(path),
       settings_(base_dir_.Append(kSettings)),
+      xattr_new_names_(false),
       initialized_() {
 }
 
 CrashReportDatabaseMac::~CrashReportDatabaseMac() {}
 
 bool CrashReportDatabaseMac::Initialize(bool may_create) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
   // Check if the database already exists.
   if (may_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;
 
-  // Write an xattr as the last step, to ensure the filesystem has support for
-  // them. This attribute will never be read.
-  if (!WriteXattrBool(base_dir_, XattrName(kXattrDatabaseInitialized), true))
-    return false;
+  // Do an xattr operation as the last step, to ensure the filesystem has
+  // support for them. This xattr also serves as a marker for whether the
+  // database uses old or new xattr names.
+  bool value;
+  if (ReadXattrBool(base_dir_,
+                    XattrNameInternal(kXattrDatabaseInitialized, true),
+                    &value) == XattrStatus::kOK &&
+      value) {
+    xattr_new_names_ = true;
+  } else if (ReadXattrBool(base_dir_,
+                           XattrNameInternal(kXattrDatabaseInitialized, false),
+                           &value) == XattrStatus::kOK &&
+             value) {
+    xattr_new_names_ = false;
+  } else {
+    xattr_new_names_ = true;
+    if (!WriteXattrBool(base_dir_, XattrName(kXattrDatabaseInitialized), true))
+      return false;
+  }
 
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 Settings* CrashReportDatabaseMac::GetSettings() {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return &settings_;
 }
 
@@ skipping 286 matching lines @@
 
 // static
 base::ScopedFD CrashReportDatabaseMac::ObtainReportLock(
     const base::FilePath& path) {
   int fd = HANDLE_EINTR(open(path.value().c_str(),
                              O_RDONLY | O_EXLOCK | O_NONBLOCK));
   PLOG_IF(ERROR, fd < 0) << "open lock " << path.value();
   return base::ScopedFD(fd);
 }
 
-// static
 bool CrashReportDatabaseMac::ReadReportMetadataLocked(
     const base::FilePath& path, Report* report) {
   std::string uuid_string;
   if (ReadXattr(path, XattrName(kXattrUUID),
                 &uuid_string) != XattrStatus::kOK ||
       !report->uuid.InitializeFromString(uuid_string)) {
     return false;
   }
 
   if (ReadXattrTimeT(path, XattrName(kXattrCreationTime),
@@ skipping 22 matching lines @@
 
   report->upload_attempts = 0;
   if (ReadXattrInt(path, XattrName(kXattrUploadAttemptCount),
                    &report->upload_attempts) == XattrStatus::kOtherError) {
     return false;
   }
 
   return true;
 }
 
-// static
 CrashReportDatabase::OperationStatus CrashReportDatabaseMac::ReportsInDirectory(
     const base::FilePath& path,
     std::vector<CrashReportDatabase::Report>* reports) {
   base::mac::ScopedNSAutoreleasePool pool;
 
   DCHECK(reports->empty());
 
   NSError* error = nil;
   NSArray* paths = [[NSFileManager defaultManager]
       contentsOfDirectoryAtPath:base::SysUTF8ToNSString(path.value())
@@ skipping 16 matching lines @@
       LOG(WARNING) << "Failed to read report metadata for "
                    << report.file_path.value();
       continue;
     }
     reports->push_back(report);
   }
 
   return kNoError;
 }
 
-// static
 std::string CrashReportDatabaseMac::XattrName(const base::StringPiece& name) {
-  return base::StringPrintf("com.googlecode.crashpad.%s", name.data());
+  return XattrNameInternal(name, xattr_new_names_);
 }
 
 scoped_ptr<CrashReportDatabase> InitializeInternal(const base::FilePath& path,
                                                    bool may_create) {
   scoped_ptr<CrashReportDatabaseMac> database_mac(
       new CrashReportDatabaseMac(path));
   if (!database_mac->Initialize(may_create))
     database_mac.reset();
 
   return scoped_ptr<CrashReportDatabase>(database_mac.release());
 }
 
 }  // namespace
 
 // static
 scoped_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
     const base::FilePath& path) {
   return InitializeInternal(path, true);
 }
 
 // static
 scoped_ptr<CrashReportDatabase> CrashReportDatabase::InitializeWithoutCreating(
     const base::FilePath& path) {
   return InitializeInternal(path, false);
 }
 
 }  // namespace crashpad