Add throttling to permission reporter

chrome/browser/safe_browsing/permission_reporter.h

 // Copyright 2016 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 CHROME_BROWSER_SAFE_BROWSING_PERMISSION_REPORTER_H_
 #define CHROME_BROWSER_SAFE_BROWSING_PERMISSION_REPORTER_H_
 
+#include <queue>
 #include <string>
+#include <unordered_map>
 
+#include "base/time/time.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "url/gurl.h"
 
 namespace net {
 class ReportSender;
 class URLRequestContext;
 }  // namespace net
 
 namespace safe_browsing {
 
+struct PermissionAndOrigin {
+  bool operator==(const PermissionAndOrigin& other) const;
+
+  content::PermissionType permission;
+  GURL origin;
+};
+
+struct PermissionAndOriginHash {
+  std::size_t operator()(
+      const PermissionAndOrigin& permission_and_origin) const;
+};
+
 // Provides functionality for building and serializing reports about permissions
 // to a report collection server.
 class PermissionReporter {
  public:
   // Creates a permission reporter that will send permission reports to
   // the SafeBrowsing permission action server, using |request_context| as the
   // context for the reports.
   explicit PermissionReporter(net::URLRequestContext* request_context);
 
   ~PermissionReporter();
@@ skipping 18 matching lines @@
   // Builds and serializes a permission report with |origin| as the origin of
   // the site requesting permission, |permission| as the type of permission
   // requested, and |action| as the action taken. The serialized report is
   // written into |output|. Returns true if the serialization was successful and
   // false otherwise.
   static bool BuildReport(const GURL& origin,
                           content::PermissionType permission,
                           PermissionAction action,
                           std::string* output);
 
+  // Returns true if the number of reports sent in the last one minute per
+  // origin per permission is less than |kMaximumReportPerOriginPerPermission|,
+  // otherwise false.

[raymes, 2016/06/27 06:26:56]

nit: probably don't reference the constant here, since it's not defined in this
file - just say "is under a threshold" or something similar

[stefanocs, 2016/06/27 07:34:57]

Done.

+  bool IsAllowedToSend(content::PermissionType permission, const GURL& origin);
+
   std::unique_ptr<net::ReportSender> permission_report_sender_;
 
+  std::unordered_map<PermissionAndOrigin,
+                     std::queue<base::Time>,

[raymes, 2016/06/27 06:26:56]

I think perhaps we can simplify this a little bit. What if we store a timestamp
whenever a send occurs and then just count the number of sends that happen since
that timestamp. If the current time is more than 1 min after the timestamp we
can reset everything.

Then we could just store:

base::Time send_timestamp_;
std::unordered_map<PermissionAndOrigin, int> send_counts_;

[stefanocs, 2016/06/27 07:34:57]

I think it would be possible to have more than five reports in window of one
minute like if reports are sent at 0, 57, 58, 59, 60, (reset here),  61, 62, 63,
64, 65 (in sec). While it still does prevents spamming to the server, it does
not exactly follow the definition, is that ok?

+                     PermissionAndOriginHash>
+      sent_histories;
+
   DISALLOW_COPY_AND_ASSIGN(PermissionReporter);
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_PERMISSION_REPORTER_H_