metrics: Add dbus interface for GetRandomPerfOutput

chrome/browser/metrics/perf_provider_chromeos.cc

 // 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.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 54 matching lines @@
 
 // Enumeration representing success and various failure modes for collecting and
 // sending perf data.
 enum GetPerfDataOutcome {
   SUCCESS,
   NOT_READY_TO_UPLOAD,
   NOT_READY_TO_COLLECT,
   INCOGNITO_ACTIVE,
   INCOGNITO_LAUNCHED,
   PROTOBUF_NOT_PARSED,
+  ILLEGAL_DATA_RETURNED,
   NUM_OUTCOMES
 };
 
 // Name of the histogram that represents the success and various failure modes
 // for collecting and sending perf data.
 const char kGetPerfDataOutcomeHistogram[] = "UMA.Perf.GetData";
 
 void AddToPerfHistogram(GetPerfDataOutcome outcome) {
   UMA_HISTOGRAM_ENUMERATION(kGetPerfDataOutcomeHistogram,
                             outcome,
                             NUM_OUTCOMES);
 }
 
 // Returns true if a normal user is logged in. Returns false otherwise (e.g. if
 // logged in as a guest or as a kiosk app).
 bool IsNormalUserLoggedIn() {
   return chromeos::LoginState::Get()->IsUserAuthenticated();
 }
 
 }  // namespace
 
+namespace metrics {
 
-namespace metrics {
+namespace {
 
 // This class must be created and used on the UI thread. It watches for any
 // incognito window being opened from the time it is instantiated to the time it
 // is destroyed.
-class WindowedIncognitoObserver : public chrome::BrowserListObserver {
+class WindowedIncognitoObserver
+    : public chrome::BrowserListObserver,
+      public PerfProvider::IncognitoObserverInterface {
  public:
   WindowedIncognitoObserver() : incognito_launched_(false) {
     BrowserList::AddObserver(this);
   }
 
   ~WindowedIncognitoObserver() override { BrowserList::RemoveObserver(this); }
 
   // This method can be checked to see whether any incognito window has been
   // opened since the time this object was created.
-  bool incognito_launched() {
+  virtual bool incognito_launched() const override {
     return incognito_launched_;
   }
 
  private:
   // chrome::BrowserListObserver implementation.
   void OnBrowserAdded(Browser* browser) override {
     if (browser->profile()->IsOffTheRecord())
       incognito_launched_ = true;
   }
 
   bool incognito_launched_;
 };
 
+}  // namespace
+
 PerfProvider::PerfProvider()
       : login_observer_(this),
         next_profiling_interval_start_(base::TimeTicks::Now()),
         weak_factory_(this) {
   // Register the login observer with LoginState.
   chromeos::LoginState::Get()->AddObserver(&login_observer_);
 
   // Register as an observer of power manager events.
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
       AddObserver(this);
@@ skipping 178 matching lines @@
 
   scoped_ptr<WindowedIncognitoObserver> incognito_observer(
       new WindowedIncognitoObserver);
 
   chromeos::DebugDaemonClient* client =
       chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
 
   base::TimeDelta collection_duration = base::TimeDelta::FromSeconds(
       kPerfCommandDurationDefaultSeconds);
 
-  client->GetPerfData(collection_duration.InSeconds(),
-                      base::Bind(&PerfProvider::ParseProtoIfValid,
-                                 weak_factory_.GetWeakPtr(),
-                                 base::Passed(&incognito_observer),
-                                 base::Passed(&sampled_profile)));
+  client->GetPerfOutput(
+      collection_duration.InSeconds(),
+      base::Bind(&PerfProvider::ParseOutputProtoIfValid,
+                 weak_factory_.GetWeakPtr(), base::Passed(&incognito_observer),
+                 base::Passed(&sampled_profile)));
 }
 
 void PerfProvider::DoPeriodicCollection() {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   CollectIfNecessary(sampled_profile.Pass());
 }
 
 void PerfProvider::CollectPerfDataAfterResume(
@@ skipping 14 matching lines @@
   // Fill out a SampledProfile protobuf that will contain the collected data.
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESTORE_SESSION);
   sampled_profile->set_ms_after_restore(time_after_restore.InMilliseconds());
   sampled_profile->set_num_tabs_restored(num_tabs_restored);
 
   CollectIfNecessary(sampled_profile.Pass());
   last_session_restore_collection_time_ = base::TimeTicks::Now();
 }
 
-void PerfProvider::ParseProtoIfValid(
-    scoped_ptr<WindowedIncognitoObserver> incognito_observer,
+void PerfProvider::ParseOutputProtoIfValid(
+    scoped_ptr<IncognitoObserverInterface> incognito_observer,
     scoped_ptr<SampledProfile> sampled_profile,
-    const std::vector<uint8>& data) {
+    int result,
+    const std::vector<uint8>& perf_data,
+    const std::vector<uint8>& perf_stat) {
   DCHECK(CalledOnValidThread());
 
   if (incognito_observer->incognito_launched()) {
     AddToPerfHistogram(INCOGNITO_LAUNCHED);
     return;
   }
 
-  PerfDataProto perf_data_proto;
-  if (!perf_data_proto.ParseFromArray(data.data(), data.size())) {
+  if (result != 0 || (perf_data.empty() && perf_stat.empty())) {
     AddToPerfHistogram(PROTOBUF_NOT_PARSED);
     return;
   }
 
-  // Populate a profile collection protobuf with the collected perf data and
-  // extra metadata.
-  cached_perf_data_.resize(cached_perf_data_.size() + 1);
-  SampledProfile& collection_data = cached_perf_data_.back();
-  collection_data.Swap(sampled_profile.get());
+  if (!perf_data.empty() && !perf_stat.empty()) {
+    AddToPerfHistogram(ILLEGAL_DATA_RETURNED);
+    return;
+  }
 
-  // Fill out remaining fields of the SampledProfile protobuf.
-  collection_data.set_ms_after_boot(
-      perf_data_proto.timestamp_sec() * base::Time::kMillisecondsPerSecond);
+  if (!perf_data.empty()) {
+    PerfDataProto perf_data_proto;
+    if (!perf_data_proto.ParseFromArray(perf_data.data(), perf_data.size())) {
+      AddToPerfHistogram(PROTOBUF_NOT_PARSED);
+      return;
+    }
+    sampled_profile->set_ms_after_boot(
+        perf_data_proto.timestamp_sec() * base::Time::kMillisecondsPerSecond);
+    sampled_profile->mutable_perf_data()->Swap(&perf_data_proto);
+  }
+
+  if (!perf_stat.empty()) {

[Ilya Sherman, 2015/07/01 03:09:02]

nit: I think it would be clearer to simply write this case as "else", maybe with
a DCHECK.

[Simon Que, 2015/07/01 20:22:57]

Done.

+    PerfStatProto perf_stat_proto;
+    if (!perf_stat_proto.ParseFromArray(perf_stat.data(), perf_stat.size())) {
+      AddToPerfHistogram(PROTOBUF_NOT_PARSED);
+      return;
+    }
+    sampled_profile->mutable_perf_stat()->Swap(&perf_stat_proto);
+  }
 
   DCHECK(!login_time_.is_null());
-  collection_data.
-      set_ms_after_login((base::TimeTicks::Now() - login_time_)
-          .InMilliseconds());
+  sampled_profile->set_ms_after_login(
+      (base::TimeTicks::Now() - login_time_).InMilliseconds());
 
-  // Finally, store the perf data itself.
-  collection_data.mutable_perf_data()->Swap(&perf_data_proto);
+  // Add the collected data to the container of collected SampledProfiles.
+  cached_perf_data_.resize(cached_perf_data_.size() + 1);
+  cached_perf_data_.back().Swap(sampled_profile.get());
 }
 
 }  // namespace metrics