win: Set last-upload-attempt time in CrashReportDatabaseWin

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 613 matching lines @@
   scoped_ptr<NewReport> scoped_report(report);
 
   // Close the outstanding handle.
   LoggingCloseFile(report->handle);
 
   // We failed to write, so remove the dump file. There's no entry in the
   // metadata table yet.
   if (!DeleteFile(scoped_report->path.value().c_str())) {
     PLOG(ERROR) << "DeleteFile "
                 << base::UTF16ToUTF8(scoped_report->path.value());
-    return CrashReportDatabase::kFileSystemError;
+    return kFileSystemError;
   }
 
   return kNoError;
 }
 
 OperationStatus CrashReportDatabaseWin::LookUpCrashReport(const UUID& uuid,
                                                           Report* report) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   scoped_ptr<Metadata> metadata(AcquireMetadata());
@@ skipping 39 matching lines @@
   // one possibility would be to change the interface to be FileHandle based, so
   // that instead of giving the file_path back to the client and changing state
   // to kUploading, we return an exclusive access handle, and use that as the
   // signal that the upload is pending, rather than an update to state in the
   // metadata. Alternatively, there could be a "garbage collection" at startup
   // where any reports that are orphaned in the kUploading state are either
   // reset to kPending to retry, or discarded.
   ReportDisk* report_disk;
   OperationStatus os = metadata->FindSingleReportAndMarkDirty(
       uuid, ReportState::kPending, &report_disk);
-  if (os == CrashReportDatabase::kNoError) {
+  if (os == kNoError) {
     report_disk->state = ReportState::kUploading;
     // Create a copy for passing back to client. This will be freed in
     // RecordUploadAttempt.
     *report = new Report(*report_disk);
   }
   return os;
 }
 
 OperationStatus CrashReportDatabaseWin::RecordUploadAttempt(
     const Report* report,
     bool successful,
     const std::string& id) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   // Take ownership, allocated in GetReportForUploading.
   scoped_ptr<const Report> upload_report(report);
   scoped_ptr<Metadata> metadata(AcquireMetadata());
   if (!metadata)
     return kDatabaseError;
   ReportDisk* report_disk;
   OperationStatus os = metadata->FindSingleReportAndMarkDirty(
       report->uuid, ReportState::kUploading, &report_disk);
-  if (os == CrashReportDatabaseWin::kNoError) {
-    report_disk->uploaded = successful;
-    report_disk->id = id;
-    report_disk->last_upload_attempt_time = time(nullptr);
-    report_disk->upload_attempts++;
-    report_disk->state =
-        successful ? ReportState::kCompleted : ReportState::kPending;
-  }
+  if (os != kNoError)
+    return os;
 
-  // Call Settings::SetLastUploadAttemptTime().
-  // https://code.google.com/p/crashpad/issues/detail?id=13.
+  time_t now = time(nullptr);
 
-  return os;
+  report_disk->uploaded = successful;
+  report_disk->id = id;
+  report_disk->last_upload_attempt_time = now;
+  report_disk->upload_attempts++;
+  report_disk->state =
+      successful ? ReportState::kCompleted : ReportState::kPending;
+
+  if (!settings_.SetLastUploadAttemptTime(now))
+    return kDatabaseError;
+
+  return kNoError;
 }
 
 OperationStatus CrashReportDatabaseWin::SkipReportUpload(const UUID& uuid) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   scoped_ptr<Metadata> metadata(AcquireMetadata());
   if (!metadata)
     return kDatabaseError;
   ReportDisk* report_disk;
   OperationStatus os = metadata->FindSingleReportAndMarkDirty(
       uuid, ReportState::kPending, &report_disk);
-  if (os == CrashReportDatabase::kNoError)
+  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));
 }
 
 }  // 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>();
 }
 
 }  // namespace crashpad