Mac 10.6 SDK compatibility

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 191 matching lines @@
   //!     to kPending.
   void AddNewRecord(const ReportDisk& new_report_disk);
 
   //! \brief Finds all reports in a given state. The \a reports vector is only
   //!     valid when CrashReportDatabase::kNoError is returned.
   //!
   //! \param[in] desired_state The state to match.
   //! \param[out] reports Matching reports, must be empty on entry.
   OperationStatus FindReports(
       ReportState desired_state,
-      std::vector<const CrashReportDatabase::Report>* reports) const;
+      std::vector<CrashReportDatabase::Report>* reports) const;
 
   //! \brief Finds the report matching the given UUID.
   //!
   //! The returned report is only valid if CrashReportDatabase::kNoError is
   //! returned.
   //!
   //! \param[in] uuid The report identifier.
   //! \param[out] report_disk The found report, valid only if
   //!     CrashReportDatabase::kNoError is returned. Ownership is not
   //!     transferred to the caller, and the report may not be modified.
@@ skipping 84 matching lines @@
 }
 
 void Metadata::AddNewRecord(const ReportDisk& new_report_disk) {
   DCHECK(new_report_disk.state == ReportState::kPending);
   reports_.push_back(new_report_disk);
   dirty_ = true;
 }
 
 OperationStatus Metadata::FindReports(
     ReportState desired_state,
-    std::vector<const CrashReportDatabase::Report>* reports) const {
+    std::vector<CrashReportDatabase::Report>* reports) const {
   DCHECK(reports->empty());
   for (const auto& report : reports_) {
     if (report.state == desired_state &&
         VerifyReport(report, desired_state) == CrashReportDatabase::kNoError) {
       reports->push_back(report);
     }
   }
   return CrashReportDatabase::kNoError;
 }
 
@@ skipping 194 matching lines @@
   ~CrashReportDatabaseWin() override;
 
   bool Initialize();
 
   // CrashReportDatabase:
   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;
+  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;
 
  private:
   scoped_ptr<Metadata> AcquireMetadata();
 
@@ skipping 89 matching lines @@
     return kDatabaseError;
   // Find and return a copy of the matching report.
   const ReportDisk* report_disk;
   OperationStatus os = metadata->FindSingleReport(uuid, &report_disk);
   if (os == kNoError)
     *report = *report_disk;
   return os;
 }
 
 OperationStatus CrashReportDatabaseWin::GetPendingReports(
-    std::vector<const Report>* reports) {
+    std::vector<Report>* reports) {
   scoped_ptr<Metadata> metadata(AcquireMetadata());
   return metadata ? metadata->FindReports(ReportState::kPending, reports)
                   : kDatabaseError;
 }
 
 OperationStatus CrashReportDatabaseWin::GetCompletedReports(
-    std::vector<const Report>* reports) {
+    std::vector<Report>* reports) {
   scoped_ptr<Metadata> metadata(AcquireMetadata());
   return metadata ? metadata->FindReports(ReportState::kCompleted, reports)
                   : kDatabaseError;
 }
 
 OperationStatus CrashReportDatabaseWin::GetReportForUploading(
     const UUID& uuid,
     const Report** report) {
   scoped_ptr<Metadata> metadata(AcquireMetadata());
   if (!metadata)
@@ skipping 65 matching lines @@
 // static
 scoped_ptr<CrashReportDatabase> CrashReportDatabase::Initialize(
     const base::FilePath& path) {
   scoped_ptr<CrashReportDatabaseWin> database_win(
       new CrashReportDatabaseWin(path.Append(kDatabaseDirectoryName)));
   return database_win->Initialize() ? database_win.Pass()
                                     : scoped_ptr<CrashReportDatabaseWin>();
 }
 
 }  // namespace crashpad