Moves ProfilerMetricsProvider to //components/metrics.

components/metrics/profiler/profiler_metrics_provider.cc

 // Copyright 2014 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/metrics/profiler_metrics_provider.h"
+#include "components/metrics/profiler/profiler_metrics_provider.h"
 
 #include <ctype.h>
 #include <string>
 #include <vector>
 
 #include "base/tracked_objects.h"
 #include "components/metrics/metrics_log.h"
 #include "components/nacl/common/nacl_process_type.h"
 #include "content/public/common/process_type.h"
 
-using metrics::ProfilerEventProto;
 using tracked_objects::ProcessDataSnapshot;
 
+namespace metrics {
+
 namespace {
 
 ProfilerEventProto::TrackedObject::ProcessType AsProtobufProcessType(
     int process_type) {
   switch (process_type) {
     case content::PROCESS_TYPE_BROWSER:
       return ProfilerEventProto::TrackedObject::BROWSER;
     case content::PROCESS_TYPE_RENDERER:
       return ProfilerEventProto::TrackedObject::RENDERER;
     case content::PROCESS_TYPE_PLUGIN:
@@ skipping 50 matching lines @@
                        int process_type,
                        ProfilerEventProto* performance_profile) {
   for (std::vector<tracked_objects::TaskSnapshot>::const_iterator it =
            profiler_data.tasks.begin();
        it != profiler_data.tasks.end();
        ++it) {
     const tracked_objects::DeathDataSnapshot& death_data = it->death_data;
     ProfilerEventProto::TrackedObject* tracked_object =
         performance_profile->add_tracked_object();
     tracked_object->set_birth_thread_name_hash(
-        metrics::MetricsLog::Hash(MapThreadName(it->birth.thread_name)));
+        MetricsLog::Hash(MapThreadName(it->birth.thread_name)));
     tracked_object->set_exec_thread_name_hash(
-        metrics::MetricsLog::Hash(MapThreadName(it->death_thread_name)));
+        MetricsLog::Hash(MapThreadName(it->death_thread_name)));
     tracked_object->set_source_file_name_hash(
-        metrics::MetricsLog::Hash(NormalizeFileName(
+        MetricsLog::Hash(NormalizeFileName(
             it->birth.location.file_name)));
     tracked_object->set_source_function_name_hash(
-        metrics::MetricsLog::Hash(it->birth.location.function_name));
+        MetricsLog::Hash(it->birth.location.function_name));
     tracked_object->set_source_line_number(it->birth.location.line_number);
     tracked_object->set_exec_count(death_data.count);
     tracked_object->set_exec_time_total(death_data.run_duration_sum);
     tracked_object->set_exec_time_sampled(death_data.run_duration_sample);
     tracked_object->set_queue_time_total(death_data.queue_duration_sum);
     tracked_object->set_queue_time_sampled(death_data.queue_duration_sample);
     tracked_object->set_process_type(AsProtobufProcessType(process_type));
     tracked_object->set_process_id(profiler_data.process_id);
   }
 }
 
 }  // namespace
 
 ProfilerMetricsProvider::ProfilerMetricsProvider() : has_profiler_data_(false) {
 }
 
 ProfilerMetricsProvider::~ProfilerMetricsProvider() {
 }
 
 void ProfilerMetricsProvider::ProvideGeneralMetrics(
-    metrics::ChromeUserMetricsExtension* uma_proto) {
+    ChromeUserMetricsExtension* uma_proto) {
   if (!has_profiler_data_)
     return;
 
   DCHECK_EQ(tracked_objects::TIME_SOURCE_TYPE_WALL_TIME,
             tracked_objects::GetTimeSourceType());
 
   DCHECK_EQ(0, uma_proto->profiler_event_size());
   ProfilerEventProto* profile = uma_proto->add_profiler_event();
   profile->Swap(&profiler_event_cache_);
   has_profiler_data_ = false;
 }
 
 void ProfilerMetricsProvider::RecordProfilerData(
     const tracked_objects::ProcessDataSnapshot& process_data,
     int process_type) {
   if (tracked_objects::GetTimeSourceType() !=
       tracked_objects::TIME_SOURCE_TYPE_WALL_TIME) {
     // We currently only support the default time source, wall clock time.
     return;
   }
 
   has_profiler_data_ = true;
   profiler_event_cache_.set_profile_type(ProfilerEventProto::STARTUP_PROFILE);
   profiler_event_cache_.set_time_source(ProfilerEventProto::WALL_CLOCK_TIME);
   WriteProfilerData(process_data, process_type, &profiler_event_cache_);
 }
+
+}  // namespace metrics