[DOMStorage] Rate limiting writes to disk.

base/time/time.h

 // Copyright (c) 2012 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.
 
 // Time represents an absolute point in coordinated universal time (UTC),
 // internally represented as microseconds (s/1,000,000) since the Windows epoch
 // (1601-01-01 00:00:00 UTC) (See http://crbug.com/14734).  System-dependent
 // clock interface routines are defined in time_PLATFORM.cc.
 //
 // TimeDelta represents a duration of time, internally represented in
@@ skipping 140 matching lines @@
     return *this;
   }
   TimeDelta& operator-=(TimeDelta other) {
     delta_ -= other.delta_;
     return *this;
   }
   TimeDelta operator-() const {
     return TimeDelta(-delta_);
   }
 
   // Computations with ints, note that we only allow multiplicative operations

[rvargas (doing something else), 2015/02/20 21:49:42]

This comment looks stale now.

[michaeln, 2015/02/20 22:18:04]

It's still valid, there is no operator+=(int).

[rvargas (doing something else), 2015/02/20 22:44:56]

"we only allow multiplicative operations with ints" is not correct anymore

   // with ints, and additive operations with other deltas.
   TimeDelta operator*(int64 a) const {
     return TimeDelta(delta_ * a);
   }
   TimeDelta operator/(int64 a) const {
     return TimeDelta(delta_ / a);
   }
   TimeDelta& operator*=(int64 a) {
     delta_ *= a;
     return *this;
   }
   TimeDelta& operator/=(int64 a) {
     delta_ /= a;
     return *this;
   }
   int64 operator/(TimeDelta a) const {
     return delta_ / a.delta_;
   }
 
+  // Multiplicative computations with floats.
+  TimeDelta multiply_by(double a) const {

[rvargas (doing something else), 2015/02/20 21:49:42]

I know that in general we prefer named methods over overloading, but all
operations are currently performed with operator overloading so it seems better
to be consistent with what this class is doing.

[michaeln, 2015/02/20 22:18:04]

i initially tried it with operators but adding an operator*(dbl) makes usages
with literal numeric values ambiguous

[rvargas (doing something else), 2015/02/20 22:44:56]

hmmm, how about 
  template<typename T>
  TimeDelta operator*(T a) const {
    return TimeDelta(delta_ * a);
  }

It extends the allowed types, but in practice we are saying that we are ok with
things that the compiler can multiply with delta_, no?

+    return TimeDelta(delta_ * a);
+  }
+  TimeDelta divide_by(double a) const {
+    return TimeDelta(delta_ / a);
+  }
+
   // Defined below because it depends on the definition of the other classes.
   Time operator+(Time t) const;
   TimeTicks operator+(TimeTicks t) const;
 
   // Comparison operators.
   bool operator==(TimeDelta other) const {
     return delta_ == other.delta_;
   }
   bool operator!=(TimeDelta other) const {
     return delta_ != other.delta_;
@@ skipping 563 matching lines @@
 inline TimeTicks TimeDelta::operator+(TimeTicks t) const {
   return TimeTicks(t.ticks_ + delta_);
 }
 
 // For logging use only.
 BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
 
 }  // namespace base
 
 #endif  // BASE_TIME_TIME_H_