NOT FOR REVIEW - Slow Reports Reference Implementation

chrome/browser/performance_monitor/performance_monitor.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 "chrome/browser/performance_monitor/performance_monitor.h"
 
 #include "base/memory/singleton.h"
 #include "base/process/process_iterator.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/tracing/crash_service_uploader.h"
+#include "content/public/browser/background_tracing_manager.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_child_process_host_iterator.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_constants.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #endif
 
 using content::BrowserThread;
 
 namespace {
 
 // The default interval at which PerformanceMonitor performs its timed
 // collections.
 const int kGatherIntervalInSeconds = 120;
 
+class CrashBackendEndpoint :
+    public content::BackgroundTracingManager::UploadSink {
+ public:
+  CrashBackendEndpoint() {
+    uploader_ = scoped_ptr<TraceCrashServiceUploader>(
+        new TraceCrashServiceUploader(
+            g_browser_process->system_request_context()));
+  }
+
+  void Upload(
+      const std::string& file_contents,
+      base::Callback<void()> done_callback) override {
+    printf("Size: %lu\n", file_contents.size());
+    printf("CrashBackendEndpoint: Uploading.\n");
+    uploader_->DoUpload(
+        file_contents,
+        base::Bind(&CrashBackendEndpoint::OnUploadProgress,
+                   this),
+        base::Bind(&CrashBackendEndpoint::OnUploadComplete,
+                   this, done_callback));
+  }
+
+  bool RequiresAnonymizedData() const override {
+    return true;
+  }
+
+ private:
+  ~CrashBackendEndpoint() override {
+  }
+
+  void OnUploadProgress(int64 current, int64 total) {
+  }
+
+  void OnUploadComplete(
+      base::Callback<void()> done_callback,
+      bool success,
+      const std::string& feedback) {
+    printf("CrashBackendEndpoint: Finished: %s\n", feedback.c_str());
+    done_callback.Run();
+  }
+
+  scoped_ptr<TraceCrashServiceUploader> uploader_;
+};
+
+class FakeEndpoint : public content::BackgroundTracingManager::UploadSink {
+ public:
+  FakeEndpoint() {
+  }
+
+  void Upload(
+      const std::string& file_contents,
+      base::Callback<void()> done_callback) override {
+    printf("Size: %lu\n", file_contents.size());
+    printf("FakeEndpoint: Not going to do anything.\n");
+    done_callback.Run();
+  }
+
+  bool RequiresAnonymizedData() const override {
+    return true;
+  }
+
+ private:
+  ~FakeEndpoint() override {
+  }
+};
+
 }  // namespace
 
 namespace performance_monitor {
 
 PerformanceMonitor::PerformanceMonitor() {
 }
 
 PerformanceMonitor::~PerformanceMonitor() {
 }
 
 // static
 PerformanceMonitor* PerformanceMonitor::GetInstance() {
   return Singleton<PerformanceMonitor>::get();
 }
 
+void DoTrigger(content::BackgroundTracingManager::TriggerHandle handle) {
+  content::BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+      handle, content::BackgroundTracingManager::StartedFinalizingCallback());
+}
+
+void CreateTestUMATrigger() {
+  content::BackgroundTracingPreemptiveConfig* config =
+      new content::BackgroundTracingPreemptiveConfig();
+
+  content::BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+  rule.type = content::BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+  rule.named_trigger_info.trigger_name = "performance_monitor";
+
+  config->configs.push_back(rule);
+
+  content::BackgroundTracingManager::GetInstance()->SetActiveScenario(
+      config,
+      new CrashBackendEndpoint());
+
+  content::BackgroundTracingManager::TriggerHandle handle =
+      content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+          "performance_monitor");
+
+  content::BrowserThread::PostDelayedTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&DoTrigger, handle),
+      base::TimeDelta::FromSeconds(3));
+}
+
 void PerformanceMonitor::StartGatherCycle() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   repeating_timer_.Start(FROM_HERE,
                          base::TimeDelta::FromSeconds(kGatherIntervalInSeconds),
                          this, &PerformanceMonitor::GatherMetricsMapOnUIThread);
+
+  content::BrowserThread::PostDelayedTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&CreateTestUMATrigger),
+      base::TimeDelta::FromSeconds(1));
 }
 
 namespace {
 
 void GatherMetricsForRenderProcess(content::RenderProcessHost* host,
                                    ProcessMetricsMetadata& data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(ENABLE_EXTENSIONS)
   content::BrowserContext* browser_context = host->GetBrowserContext();
   extensions::ProcessMap* extension_process_map =
@@ skipping 105 matching lines @@
       // Not touched this iteration; let's get rid of it.
       metrics_map_.erase(iter++);
     } else {
       process_metrics.SampleMetrics();
       ++iter;
     }
   }
 }
 
 }  // namespace performance_monitor