CrashReportDatabse: set the last upload attempt time from RecordUploadAttempt()

client/crash_report_database_test.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,
 // 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 <sys/stat.h>
 
+#include "build/build_config.h"
+#include "client/settings.h"
 #include "gtest/gtest.h"
 #include "util/file/file_io.h"
 #include "util/test/errors.h"
 #include "util/test/scoped_temp_dir.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 bool FileExistsAtPath(const base::FilePath& path) {
@@ skipping 38 matching lines @@
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->FinishedWritingCrashReport(new_report, &uuid));
 
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->LookUpCrashReport(uuid, report));
     ExpectPreparedCrashReport(*report);
     ASSERT_TRUE(FileExistsAtPath(report->file_path));
   }
 
   void UploadReport(const UUID& uuid, bool successful, const std::string& id) {
+#if !defined(OS_WIN)
+    // Enable when ported to Windows.
+    // https://code.google.com/p/crashpad/issues/detail?id=13
+    Settings* const settings = db_->GetSettings();
+    ASSERT_TRUE(settings);
+    time_t times[2];
+    ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[0]));
+#endif
+
     const CrashReportDatabase::Report* report = nullptr;
     ASSERT_EQ(CrashReportDatabase::kNoError,
               db_->GetReportForUploading(uuid, &report));
     EXPECT_NE(UUID(), report->uuid);
     EXPECT_FALSE(report->file_path.empty());
     EXPECT_TRUE(FileExistsAtPath(report->file_path))
         << report->file_path.value();
     EXPECT_GT(report->creation_time, 0);
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->RecordUploadAttempt(report, successful, id));
+
+#if !defined(OS_WIN)
+    // Enable when ported to Windows.
+    // https://code.google.com/p/crashpad/issues/detail?id=13
+    ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[1]));
+    EXPECT_NE(times[1], 0);
+    EXPECT_GE(times[1], times[0]);
+#endif
   }
 
   void ExpectPreparedCrashReport(const CrashReportDatabase::Report& report) {
     EXPECT_NE(UUID(), report.uuid);
     EXPECT_FALSE(report.file_path.empty());
     EXPECT_TRUE(FileExistsAtPath(report.file_path)) << report.file_path.value();
     EXPECT_TRUE(report.id.empty());
     EXPECT_GT(report.creation_time, 0);
     EXPECT_FALSE(report.uploaded);
     EXPECT_EQ(0, report.last_upload_attempt_time);
     EXPECT_EQ(0, report.upload_attempts);
   }
 
   void RelocateDatabase() {
     ResetDatabase();
     temp_dir_.Rename();
     SetUp();
   }
 
  private:
   ScopedTempDir temp_dir_;
   scoped_ptr<CrashReportDatabase> db_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashReportDatabaseTest);
 };
 
 TEST_F(CrashReportDatabaseTest, Initialize) {
   // Initialize the database for the first time, creating it.
-  EXPECT_TRUE(db());
+  ASSERT_TRUE(db());
+
+#if !defined(OS_WIN)
+  // Enable when ported to Windows.
+  // https://code.google.com/p/crashpad/issues/detail?id=13
+  Settings* settings = db()->GetSettings();
+
+  UUID client_ids[2];
+  ASSERT_TRUE(settings->GetClientID(&client_ids[0]));
+  EXPECT_NE(client_ids[0], UUID());
+
+  time_t last_upload_attempt_time;
+  ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
+  EXPECT_EQ(0, last_upload_attempt_time);
+#endif
 
   // Close and reopen the database at the same path.
   ResetDatabase();
   EXPECT_FALSE(db());
   auto db = CrashReportDatabase::Initialize(path());
   ASSERT_TRUE(db);
 
+#if !defined(OS_WIN)
+  // Enable when ported to Windows.
+  // https://code.google.com/p/crashpad/issues/detail?id=13
+  settings = db->GetSettings();
+
+  ASSERT_TRUE(settings->GetClientID(&client_ids[1]));
+  EXPECT_EQ(client_ids[0], client_ids[1]);
+
+  ASSERT_TRUE(settings->GetLastUploadAttemptTime(&last_upload_attempt_time));
+  EXPECT_EQ(0, last_upload_attempt_time);
+#endif
+
   std::vector<CrashReportDatabase::Report> reports;
   EXPECT_EQ(CrashReportDatabase::kNoError, db->GetPendingReports(&reports));
   EXPECT_TRUE(reports.empty());
   reports.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError, db->GetCompletedReports(&reports));
   EXPECT_TRUE(reports.empty());
 }
 
 TEST_F(CrashReportDatabaseTest, NewCrashReport) {
   CrashReportDatabase::NewReport* new_report;
@@ skipping 335 matching lines @@
       << ErrnoMessage("unlink");
 #endif
 
   EXPECT_EQ(CrashReportDatabase::kReportNotFound,
             db()->LookUpCrashReport(uuid, &report));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad