Update Crashpad to b35ee1fca18956f3c27ba124d6dc456a723c7670

third_party/crashpad/crashpad/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 85 matching lines @@
 
 enum class ReportState {
   //! \brief Created and filled out by caller, owned by database.
   kPending,
   //! \brief In the process of uploading, owned by caller.
   kUploading,
   //! \brief Upload completed or skipped, owned by database.
   kCompleted,
 };
 
+enum {
+  //! \brief Corresponds to uploaded bit of the report state.
+  kAttributeUploaded = 1 << 0,
+
+  //! \brief Corresponds to upload_explicity_requested bit of the report state.
+  kAttributeUploadExplicitlyRequested = 1 << 1,
+};
+
 struct MetadataFileReportRecord {
   // Note that this default constructor does no initialization. It is used only
   // to create an array of records that are immediately initialized by reading
   // from disk in Metadata::Read().
   MetadataFileReportRecord() {}
 
   // Constructs from a ReportDisk, adding to |string_table| and storing indices
   // as strings into that table.
   MetadataFileReportRecord(const ReportDisk& report, std::string* string_table);
 
   UUID uuid;  // UUID is a 16 byte, standard layout structure.
   uint32_t file_path_index;  // Index into string table. File name is relative
                              // to the reports directory when on disk.
   uint32_t id_index;  // Index into string table.
   int64_t creation_time;  // Holds a time_t.
   int64_t last_upload_attempt_time;  // Holds a time_t.
   int32_t upload_attempts;
   int32_t state;  // A ReportState.
-  uint8_t uploaded;  // Boolean, 0 or 1.
+  uint8_t attributes;  // Bitfield of kAttribute*.
   uint8_t padding[7];
 };
 
 //! \brief A private extension of the Report class that includes additional data
 //!     that's stored on disk in the metadata file.
 struct ReportDisk : public CrashReportDatabase::Report {
   ReportDisk(const MetadataFileReportRecord& record,
              const base::FilePath& report_dir,
              const std::string& string_table);
 
   ReportDisk(const UUID& uuid,
              const base::FilePath& path,
              time_t creation_tim,
              ReportState state);
 
   //! \brief The current state of the report.
   ReportState state;
 };
 
 MetadataFileReportRecord::MetadataFileReportRecord(const ReportDisk& report,
                                                    std::string* string_table)
     : uuid(report.uuid),
       file_path_index(
           AddStringToTable(string_table, report.file_path.BaseName().value())),
       id_index(AddStringToTable(string_table, report.id)),
       creation_time(report.creation_time),
       last_upload_attempt_time(report.last_upload_attempt_time),
       upload_attempts(report.upload_attempts),
       state(static_cast<uint32_t>(report.state)),
-      uploaded(report.uploaded) {
+      attributes((report.uploaded ? kAttributeUploaded : 0) |
+                 (report.upload_explicitly_requested
+                      ? kAttributeUploadExplicitlyRequested
+                      : 0)) {
   memset(&padding, 0, sizeof(padding));
 }
 
 ReportDisk::ReportDisk(const MetadataFileReportRecord& record,
                        const base::FilePath& report_dir,
                        const std::string& string_table)
     : Report() {
   uuid = record.uuid;
   file_path = report_dir.Append(
       base::UTF8ToUTF16(&string_table[record.file_path_index]));
   id = &string_table[record.id_index];
   creation_time = record.creation_time;
-  uploaded = record.uploaded != 0;
   last_upload_attempt_time = record.last_upload_attempt_time;
   upload_attempts = record.upload_attempts;
   state = static_cast<ReportState>(record.state);
+  uploaded = (record.attributes & kAttributeUploaded) != 0;
+  upload_explicitly_requested =
+      (record.attributes & kAttributeUploadExplicitlyRequested) != 0;
 }
 
 ReportDisk::ReportDisk(const UUID& uuid,
                        const base::FilePath& path,
                        time_t creation_time,
                        ReportState state)
     : Report() {
   this->uuid = uuid;
   this->file_path = path;
   this->creation_time = creation_time;
@@ skipping 389 matching lines @@
   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;
   OperationStatus DeleteReport(const UUID& uuid) override;
+  OperationStatus RequestUpload(const UUID& uuid) override;
 
  private:
   std::unique_ptr<Metadata> AcquireMetadata();
 
   base::FilePath base_dir_;
   Settings settings_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseWin);
 };
@@ skipping 176 matching lines @@
       report->uuid, ReportState::kUploading, &report_disk);
   if (os != kNoError)
     return os;
 
   time_t now = time(nullptr);
 
   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 (successful) {
+    report_disk->state = ReportState::kCompleted;
+    report_disk->upload_explicitly_requested = false;
+  } else {
+    report_disk->state = ReportState::kPending;
+    report_disk->upload_explicitly_requested =
+        report->upload_explicitly_requested;
+  }
 
   if (!settings_.SetLastUploadAttemptTime(now))
     return kDatabaseError;
 
   return kNoError;
 }
 
 OperationStatus CrashReportDatabaseWin::DeleteReport(const UUID& uuid) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
@@ skipping 16 matching lines @@
 
 OperationStatus CrashReportDatabaseWin::SkipReportUpload(const UUID& uuid) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   std::unique_ptr<Metadata> metadata(AcquireMetadata());
   if (!metadata)
     return kDatabaseError;
   ReportDisk* report_disk;
   OperationStatus os = metadata->FindSingleReportAndMarkDirty(
       uuid, ReportState::kPending, &report_disk);
-  if (os == kNoError)
+  if (os == kNoError) {
     report_disk->state = ReportState::kCompleted;
+    report_disk->upload_explicitly_requested = false;
+  }
   return os;
 }
 
 std::unique_ptr<Metadata> CrashReportDatabaseWin::AcquireMetadata() {
   base::FilePath metadata_file = base_dir_.Append(kMetadataFileName);
   return Metadata::Create(metadata_file, base_dir_.Append(kReportsDirectory));
 }
 
 std::unique_ptr<CrashReportDatabase> InitializeInternal(
     const base::FilePath& path,
     bool may_create) {
   std::unique_ptr<CrashReportDatabaseWin> database_win(
       new CrashReportDatabaseWin(path));
   return database_win->Initialize(may_create)
              ? std::move(database_win)
              : std::unique_ptr<CrashReportDatabaseWin>();
 }
 
+OperationStatus CrashReportDatabaseWin::RequestUpload(const UUID& uuid) {
+  INITIALIZATION_STATE_DCHECK_VALID(initialized_);
+
+  std::unique_ptr<Metadata> metadata(AcquireMetadata());
+  if (!metadata)
+    return kDatabaseError;
+
+  ReportDisk* report_disk;
+  // TODO(gayane): Search for the report only once regardless of its state.
+  OperationStatus os = metadata->FindSingleReportAndMarkDirty(
+      uuid, ReportState::kCompleted, &report_disk);
+  if (os == kBusyError) {
+    os = metadata->FindSingleReportAndMarkDirty(
+        uuid, ReportState::kPending, &report_disk);
+  }
+
+  if (os != kNoError)
+    return os;
+
+  // If the crash report has already been uploaded, don't request new upload.
+  if (report_disk->uploaded)
+    return kCannotRequestUpload;
+
+  // Mark the crash report as having upload explicitly requested by the user,
+  // and move it to the pending state.
+  report_disk->upload_explicitly_requested = true;
+  report_disk->state = ReportState::kPending;
+
+  return kNoError;
+}
+
 }  // namespace
 
 // static
 std::unique_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
     const base::FilePath& path) {
   return InitializeInternal(path, true);
 }
 
 // static
 std::unique_ptr<CrashReportDatabase>
 CrashReportDatabase::InitializeWithoutCreating(const base::FilePath& path) {
   return InitializeInternal(path, false);
 }
 
 }  // namespace crashpad