[Chromecast] Move SynchronizedMinidumpManager ratelimit logic to child classes.

chromecast/crash/linux/synchronized_minidump_manager.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromecast/crash/linux/synchronized_minidump_manager.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
@@ skipping 104 matching lines @@
   DCHECK_GE(period_dumps, 0);
 
   base::DictionaryValue* ratelimit_params = GetRatelimitParams(metadata);
   RCHECK(ratelimit_params, -1);
 
   ratelimit_params->SetInteger(kLockfileRatelimitPeriodDumpsKey, period_dumps);
 
   return 0;
 }
 
-// Increment the number of dumps in the current ratelimit period in deserialized
-// |metadata| by |increment|. Returns 0 on success, < 0 on error.
-int IncrementCurrentPeriodDumps(base::Value* metadata, int increment) {
-  DCHECK_GE(increment, 0);
-  int last_dumps = GetRatelimitPeriodDumps(metadata);
-  RCHECK(last_dumps >= 0, -1);
-
-  return SetRatelimitPeriodDumps(metadata, last_dumps + increment);
-}
-
 // Returns true if |metadata| contains valid metadata, false otherwise.
 bool ValidateMetadata(base::Value* metadata) {
   RCHECK(metadata, false);
 
   // Validate ratelimit params
   base::DictionaryValue* ratelimit_params = GetRatelimitParams(metadata);
 
   return ratelimit_params &&
          ratelimit_params->size() == kLockfileNumRatelimitParams &&
          GetRatelimitPeriodStart(metadata) >= 0 &&
          GetRatelimitPeriodDumps(metadata) >= 0;
 }
 
 }  // namespace
 
-const int SynchronizedMinidumpManager::kMaxLockfileDumps = 5;
-
 // One day
 const int SynchronizedMinidumpManager::kRatelimitPeriodSeconds = 24 * 3600;
 const int SynchronizedMinidumpManager::kRatelimitPeriodMaxDumps = 100;
 
 SynchronizedMinidumpManager::SynchronizedMinidumpManager()
     : non_blocking_(false),
       dump_path_(GetHomePathASCII(kMinidumpsDir)),
       lockfile_path_(dump_path_.Append(kLockfileName).value()),
       metadata_path_(dump_path_.Append(kMetadataName).value()),
       lockfile_fd_(-1) {
@@ skipping 169 matching lines @@
 int SynchronizedMinidumpManager::AddEntryToLockFile(const DumpInfo& dump_info) {
   DCHECK_LE(0, lockfile_fd_);
   DCHECK(dumps_);
 
   // Make sure dump_info is valid.
   if (!dump_info.valid()) {
     LOG(ERROR) << "Entry to be added is invalid";
     return -1;
   }
 
-  if (!CanWriteDumps(1)) {
-    LOG(ERROR) << "Can't Add Dump: Ratelimited";
-    return -1;
-  }
-
-  IncrementCurrentPeriodDumps(metadata_.get(), 1);
   dumps_->Append(dump_info.GetAsValue());
 
   return 0;
 }
 
 int SynchronizedMinidumpManager::RemoveEntryFromLockFile(int index) {
   return dumps_->Remove(static_cast<size_t>(index), nullptr) ? 0 : -1;
 }
 
 void SynchronizedMinidumpManager::ReleaseLockFile() {
@@ skipping 27 matching lines @@
 int SynchronizedMinidumpManager::SetCurrentDumps(
     const ScopedVector<DumpInfo>& dumps) {
   dumps_->Clear();
 
   for (DumpInfo* dump : dumps)
     dumps_->Append(dump->GetAsValue());
 
   return 0;
 }
 
-bool SynchronizedMinidumpManager::CanWriteDumps(int num_dumps) {
-  const auto dumps(GetDumps());
+int SynchronizedMinidumpManager::IncrementRatelimitPeriodDumps() {
+  DCHECK(metadata_);
+  int last_dumps = GetRatelimitPeriodDumps(metadata_.get());
+  RCHECK(last_dumps >= 0, -1);
 
-  // If no more dumps can be written, return false.
-  if (static_cast<int>(dumps.size()) + num_dumps > kMaxLockfileDumps)
-    return false;
+  return SetRatelimitPeriodDumps(metadata_.get(), last_dumps + 1);
+}
 
-  // If too many dumps have been written recently, return false.
+bool SynchronizedMinidumpManager::CanUploadDump() {
   time_t cur_time = time(nullptr);
   time_t period_start = GetRatelimitPeriodStart(metadata_.get());
   int period_dumps_count = GetRatelimitPeriodDumps(metadata_.get());
 
   // If we're in invalid state, or we passed the period, reset the ratelimit.
   // When the device reboots, |cur_time| may be incorrectly reported to be a
   // very small number for a short period of time. So only consider
   // |period_start| invalid when |cur_time| is less if |cur_time| is not very
   // close to 0.
   if (period_dumps_count < 0 ||
       (cur_time < period_start && cur_time > kRatelimitPeriodSeconds) ||
       difftime(cur_time, period_start) >= kRatelimitPeriodSeconds) {
     period_start = cur_time;
     period_dumps_count = 0;
     SetRatelimitPeriodStart(metadata_.get(), period_start);
     SetRatelimitPeriodDumps(metadata_.get(), period_dumps_count);
   }
 
-  return period_dumps_count + num_dumps <= kRatelimitPeriodMaxDumps;
+  return period_dumps_count < kRatelimitPeriodMaxDumps;
 }
 
 }  // namespace chromecast