RAPPOR implementation

components/rappor/rappor_service.cc

+// Copyright (c) 2013 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 "components/rappor/rappor_service.h"
+
+#include <cstdlib>
+
+#include "base/base64.h"
+#include "base/hash.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/pref_service.h"
+#include "base/rand_util.h"
+#include "base/stl_util.h"
+#include "components/rappor/proto/rappor_metric.pb.h"
+#include "components/rappor/rappor_pref_names.h"
+
+namespace {
+
+// Seconds before the initial log is generated.
+const int kInitialLogIntervalSeconds = 15;
+// Interval between ongoing logs.
+const int kLogIntervalSeconds = 30 * 60;
+
+const char kServerUrl[] = "http://localhost:1234/rappor/v2";
+const char kMimeType[] = "application/vnd.chrome.uma";
+
+}  // namespace
+
+namespace rappor {
+
+RapporService::RapporService() : uploader_(kServerUrl, kMimeType) {}
+
+RapporService::~RapporService() {}
+
+void RapporService::Start(PrefService* pref_service,
+                          net::URLRequestContextGetter* request_context) {
+  GenerateRapporSecret(pref_service);
+  uploader_.SetRequestContext(request_context);
+  log_rotation_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
+      this,
+      &RapporService::OnLogInterval);
+}
+
+void RapporService::OnLogInterval() {
+  rappor_metrics_proto_.Clear();
+  LogRapporMetrics();
+  if (rappor_metrics_proto_.rappor_size() > 0) {
+    std::string log_text;
+    bool success = rappor_metrics_proto_.SerializeToString(&log_text);
+    DCHECK(success);
+    uploader_.QueueLog(log_text);
+  }
+  log_rotation_timer_.Start(FROM_HERE,
+                            base::TimeDelta::FromSeconds(kLogIntervalSeconds),
+                            this,
+                            &RapporService::OnLogInterval);
+}
+
+// static
+void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
+  registry->RegisterStringPref(prefs::kRapporSecret, std::string());
+}
+
+void RapporService::GenerateRapporSecret(PrefService* pref_service) {
+  if (!rappor_secret_.empty())
+    return;
+  std::string rappor_secret_64 = pref_service->GetString(prefs::kRapporSecret);
+  if (!rappor_secret_64.empty()) {
+    bool decoded = base::Base64Decode(rappor_secret_64, &rappor_secret_);
+    if (decoded)
+      return;
+  }
+
+  rappor_secret_ = base::RandBytesAsString(128);
+  bool encoded = base::Base64Encode(rappor_secret_, &rappor_secret_64);
+  DCHECK(encoded);
+  pref_service->SetString(prefs::kRapporSecret, rappor_secret_64);
+}
+
+void RapporService::LogRappor(const RapporMetric& rappor) {
+  RapporMetricsProto::RapporMetric* metric = rappor_metrics_proto_.add_rappor();
+  metric->set_name_hash(base::Hash(rappor.parameters()->rappor_name));
+  ByteVector bytes = rappor.GetReport(rappor_secret_);
+  std::string byte_string(bytes.begin(), bytes.end());
+  metric->set_bits(byte_string);
+}
+
+void RapporService::LogRapporMetrics() {
+  base::AutoLock auto_lock(lock_);
+
+  for (RapporMap::iterator it = rappors_.begin(); rappors_.end() != it; ++it) {
+    const RapporMetric* rappor = it->second;
+    DCHECK_EQ(it->first, rappor->parameters()->rappor_name);
+    LogRappor(*rappor);
+  }
+  STLDeleteContainerPairSecondPointers(rappors_.begin(), rappors_.end());
+  rappors_.clear();
+}
+
+void RapporService::RecordSamples(const RapporParameters& parameters,
+                                  const std::vector<std::string>& samples) {
+  base::AutoLock auto_lock(lock_);
+
+  RapporMetric* rappor = GetRapporMetric(parameters);
+  rappor->AddSamples(samples);
+}
+
+RapporMetric* RapporService::GetRapporMetric(
+    const RapporParameters& parameters) {
+  RapporMap::iterator it = rappors_.find(parameters.rappor_name);
+  if (rappors_.end() != it) {
+    RapporMetric* rappor = it->second;
+    DCHECK_EQ(parameters.rappor_name, rappor->parameters()->rappor_name);
+    DCHECK_EQ(parameters.bloom_filter_size_bytes,
+        rappor->parameters()->bloom_filter_size_bytes);
+    DCHECK_EQ(parameters.bloom_filter_hash_count,
+        rappor->parameters()->bloom_filter_hash_count);
+    DCHECK_EQ(parameters.fake_prob, rappor->parameters()->fake_prob);
+    DCHECK_EQ(parameters.fake_one_prob, rappor->parameters()->fake_one_prob);
+    DCHECK_EQ(parameters.one_coin_prob, rappor->parameters()->one_coin_prob);
+    DCHECK_EQ(parameters.zero_coin_prob, rappor->parameters()->zero_coin_prob);
+    return rappor;
+  }
+
+  RapporMetric* new_rappor = new RapporMetric(parameters);
+  rappors_[parameters.rappor_name] = new_rappor;
+  return new_rappor;
+}
+
+}  // namespace rappor