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";

[Ilya Sherman, 2014/01/10 11:00:32]

nit: Please update this, yadda yadda.

[Steven Holte, 2014/01/15 04:53:44]

Updated this, assuming the collector will extend the UMA one.

+const char kMimeType[] = "application/vnd.chrome.uma";

[Ilya Sherman, 2014/01/10 11:00:32]

nit: This too, probably, though I bet it doesn't really matter.

[Steven Holte, 2014/01/15 04:53:44]

It doesn't seem to matter, but I changed it.

+
+}  // namespace
+
+namespace rappor {
+
+RapporService::RapporService() : uploader_(NULL) {}
+
+RapporService::~RapporService() {
+  if (uploader_)
+    delete uploader_;

[Ilya Sherman, 2014/01/10 11:00:32]

No no no.  Please use a smart pointer instead.

[Steven Holte, 2014/01/15 04:53:44]

Done.

+}
+
+void RapporService::Start(PrefService* pref_service,
+                          net::URLRequestContextGetter* request_context) {
+  DCHECK(!uploader_);
+  GenerateRapporSecret(pref_service);
+  uploader_ = new LogUploader(kServerUrl, kMimeType, request_context);
+  log_rotation_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
+      this,
+      &RapporService::OnLogInterval);
+}
+
+void RapporService::OnLogInterval() {
+  DCHECK(uploader_);
+  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);

[Ilya Sherman, 2014/01/10 11:00:32]

nit: I think "_base64" would be clearer than just "_64", which makes me think
this is a 64-bit value or something.

[Steven Holte, 2014/01/15 04:53:44]

Done.

+  if (!rappor_secret_64.empty()) {
+    bool decoded = base::Base64Decode(rappor_secret_64, &rappor_secret_);
+    if (decoded)
+      return;

[Ilya Sherman, 2014/01/10 11:00:32]

Is there a reason to expect that decoding might fail?  If so, please document
that.  (I'm assuming you're worried about corrupted prefs).

[Steven Holte, 2014/01/15 04:53:44]

Done.

+  }
+
+  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);
+}
+
+void RapporService::RecordUrl(const RapporParameters& parameters,
+                              const GURL& url) {
+  std::vector<std::string> samples;
+  samples.push_back(url.spec());
+  samples.push_back(url.host());
+  // TODO(holte) break up host more

[Ilya Sherman, 2014/01/10 11:00:32]

nit: "TODO(holte)" -> "TODO(holte):"

[Steven Holte, 2014/01/15 04:53:44]

Done.

+  samples.push_back(url.query());
+  samples.push_back(url.path());
+  RecordSamples(parameters, samples);
+}
+
+RapporMetric* RapporService::GetRapporMetric(

[Ilya Sherman, 2014/01/10 11:00:32]

Please return a scoped_ptr to indicate transfer of memory ownership.

[Steven Holte, 2014/01/15 04:53:44]

There is no transfer of ownership here.  This is a private method that gets a
value stored in the private map. 

+    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);

[Ilya Sherman, 2014/01/10 11:00:32]

nit: How about just DCHECK_EQ(parameters, rappor->parameters), or
DCHECK(parameters == rappor->parameters) if you don't want to write string
serialization code for the parameters struct?  That seems less likely to bitrot
in case any new fields are added to the struct.

+    return rappor;
+  }
+
+  RapporMetric* new_rappor = new RapporMetric(parameters);
+  rappors_[parameters.rappor_name] = new_rappor;
+  return new_rappor;
+}
+
+}  // namespace rappor