Remove explicit keyword from multi-argument constructors

chrome/browser/extensions/extensions_quota_service.h

 // Copyright (c) 2011 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.
 
 // The ExtensionsQuotaService uses heuristics to limit abusive requests
 // made by extensions.  In this model 'items' (e.g individual bookmarks) are
 // represented by a 'Bucket' that holds state for that item for one single
 // interval of time.  The interval of time is defined as 'how long we need to
 // watch an item (for a particular heuristic) before making a decision about
 // quota violations'.  A heuristic is two functions: one mapping input
@@ skipping 124 matching lines @@
     // In most cases, this should simply extract item IDs from the arguments
     // (e.g for bookmark operations involving an existing item). If a problem
     // occurs while parsing |args|, the function aborts - buckets may be non-
     // empty). The expectation is that invalid args and associated errors are
     // handled by the ExtensionFunction itself so we don't concern ourselves.
     virtual void GetBucketsForArgs(const ListValue* args,
                                    BucketList* buckets) = 0;
   };
 
   // Ownership of |mapper| is given to the new QuotaLimitHeuristic.
-  explicit QuotaLimitHeuristic(const Config& config, BucketMapper* map);
+  QuotaLimitHeuristic(const Config& config, BucketMapper* map);
   virtual ~QuotaLimitHeuristic();
 
   // Determines if sufficient quota exists (according to the Apply
   // implementation of a derived class) to perform an operation with |args|,
   // based on the history of similar operations with similar arguments (which
   // is retrieved using the BucketMapper).
   bool ApplyToArgs(const ListValue* args, const base::TimeTicks& event_time);
 
  protected:
   const Config& config() { return config_; }
@@ skipping 10 matching lines @@
   // The mapper used in Map.  Cannot be NULL.
   scoped_ptr<BucketMapper> bucket_mapper_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaLimitHeuristic);
 };
 
 // A simple per-item heuristic to limit the number of events that can occur in
 // a given period of time; e.g "no more than 100 events in an hour".
 class ExtensionsQuotaService::TimedLimit : public QuotaLimitHeuristic {
  public:
-  explicit TimedLimit(const Config& config, BucketMapper* map)
+  TimedLimit(const Config& config, BucketMapper* map)
       : QuotaLimitHeuristic(config, map) {}
   virtual bool Apply(Bucket* bucket, const base::TimeTicks& event_time);
 };
 
 // A per-item heuristic to limit the number of events that can occur in a
 // period of time over a sustained longer interval. E.g "no more than two
 // events per minute, sustained over 10 minutes".
 class ExtensionsQuotaService::SustainedLimit : public QuotaLimitHeuristic {
  public:
   SustainedLimit(const base::TimeDelta& sustain,
                  const Config& config,
                  BucketMapper* map);
   virtual bool Apply(Bucket* bucket, const base::TimeTicks& event_time);
  private:
   // Specifies how long exhaustion of buckets is allowed to continue before
   // denying requests.
   const int64 repeat_exhaustion_allowance_;
   int64 num_available_repeat_exhaustions_;
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSIONS_QUOTA_SERVICE_H_