[Chromecast] Move SynchronizedMinidumpManager ratelimit logic to child classes.

chromecast/crash/linux/synchronized_minidump_manager.h

 // 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.
 
 #ifndef CHROMECAST_CRASH_LINUX_SYNCHRONIZED_MINIDUMP_MANAGER_H_
 #define CHROMECAST_CRASH_LINUX_SYNCHRONIZED_MINIDUMP_MANAGER_H_
 
 #include <time.h>
 
 #include <string>
@@ skipping 28 matching lines @@
 // that producers to this file do not need to understand json.
 //
 // Current external producers:
 // + watchdog
 //
 //
 // The metadata file is a separate file containing a json dictionary.
 //
 class SynchronizedMinidumpManager {
  public:
-  // Max number of dumps allowed in lockfile.
-  static const int kMaxLockfileDumps;
-
   // Length of a ratelimit period in seconds.
   static const int kRatelimitPeriodSeconds;
 
   // Number of dumps allowed per period.
   static const int kRatelimitPeriodMaxDumps;
 
   virtual ~SynchronizedMinidumpManager();
 
   // Returns whether this object's file locking method is nonblocking or not.
   bool non_blocking() { return non_blocking_; }
@@ skipping 31 matching lines @@
   // Remove the lockfile entry at |index| in the current in memory
   // representation of the lockfile. If the index is invalid returns -1.
   // Otherwise returns 0.
   int RemoveEntryFromLockFile(int index);
 
   // Get the number of un-uploaded dumps in the dump_path directory.
   // If delete_all_dumps is true, also delete all these files, this is used to
   // clean lingering dump files.
   int GetNumDumps(bool delete_all_dumps);
 
+  // Increment the number of dumps in the current ratelimit period.
+  // Returns 0 on success, < 0 on error.
+  int IncrementRatelimitPeriodDumps();

[slan, 2015/09/09 19:08:11]

This name is confusing to me. Perhaps IncrementNumDumpsInCurrentPeriod()?

[bcf_google, 2015/09/09 21:20:29]

Done.

+
+  // Returns true when dumps uploaded in current rate limit period is less than
+  // |kRatelimitPeriodMaxDumps|. Resets rate limit period if period time has
+  // elapsed.
+  bool CanUploadDump();
+
   // If true, the flock on the lockfile will be nonblocking.
   bool non_blocking_;
 
   // Cached path for the minidumps directory.
   const base::FilePath dump_path_;
 
  private:
   // Acquire the lock file. Blocks if another process holds it, or if called
   // a second time by the same process. Returns the fd of the lockfile if
   // successful, or -1 if failed.
   int AcquireLockFile();
 
   // Parse the lockfile and metadata file, populating |dumps_| and |metadata_|
   // for modifier functions to use. Return -1 if an error occurred. Otherwise,
   // return 0. This must not be called unless |this| has acquired the lock.
   int ParseFiles();
 
   // Write deserialized |dumps| to |lockfile_path_| and the deserialized
   // |metadata| to |metadata_path_|.
   int WriteFiles(const base::ListValue* dumps, const base::Value* metadata);
 
   // Creates an empty lock file and an initialized metadata file.
   int InitializeFiles();
 
   // Release the lock file with the associated *fd*.
   void ReleaseLockFile();
 
-  // Returns true if |num_dumps| can be written to the lockfile. We can write
-  // the dumps if the number of dumps in the lockfile after |num_dumps| is added
-  // is less than or equal to |kMaxLockfileDumps| and the number of dumps in the
-  // current ratelimit period after |num_dumps| is added is less than or equal
-  // to |kRatelimitPeriodMaxDumps|.
-  bool CanWriteDumps(int num_dumps);
-
   const std::string lockfile_path_;
   const std::string metadata_path_;
   int lockfile_fd_;
   scoped_ptr<base::Value> metadata_;
   scoped_ptr<base::ListValue> dumps_;
 
   DISALLOW_COPY_AND_ASSIGN(SynchronizedMinidumpManager);
 };
 
 }  // namespace chromecast
 
 #endif  // CHROMECAST_CRASH_LINUX_SYNCHRONIZED_MINIDUMP_MANAGER_H_