Split the ProcessType enum into process types that content knows about (which will remain in src\co…

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 169 matching lines @@
 #include "chrome/browser/metrics/metrics_reporting_scheduler.h"
 #include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
 #include "chrome/browser/net/network_stats.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_otr_state.h"
 #include "chrome/common/child_process_logging.h"
+#include "chrome/common/chrome_process_type.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/metrics/entropy_provider.h"
 #include "chrome/common/metrics/metrics_log_manager.h"
 #include "chrome/common/net/test_server_locations.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/histogram_fetcher.h"
@@ skipping 128 matching lines @@
 // static
 MetricsService::ShutdownCleanliness MetricsService::clean_shutdown_status_ =
     MetricsService::CLEANLY_SHUTDOWN;
 
 // This is used to quickly log stats from child process related notifications in
 // MetricsService::child_stats_buffer_.  The buffer's contents are transferred
 // out when Local State is periodically saved.  The information is then
 // reported to the UMA server on next launch.
 struct MetricsService::ChildProcessStats {
  public:
-  explicit ChildProcessStats(content::ProcessType type)
+  explicit ChildProcessStats(int process_type)
       : process_launches(0),
         process_crashes(0),
         instances(0),
         loading_errors(0),
-        process_type(type) {}
+        process_type(process_type) {}
 
   // This constructor is only used by the map to return some default value for
   // an index for which no value has been assigned.
   ChildProcessStats()
       : process_launches(0),
         process_crashes(0),
         instances(0),
         loading_errors(0),
         process_type(content::PROCESS_TYPE_UNKNOWN) {}
 
   // The number of times that the given child process has been launched
   int process_launches;
 
   // The number of times that the given child process has crashed
   int process_crashes;
 
   // The number of instances of this child process that have been created.
   // An instance is a DOM object rendered by this child process during a page
   // load.
   int instances;
 
   // The number of times there was an error loading an instance of this child
   // process.
   int loading_errors;
 
-  content::ProcessType process_type;
+  int process_type;
 };
 
 // Handles asynchronous fetching of memory details.
 // Will run the provided task after finished.
 class MetricsMemoryDetails : public MemoryDetails {
  public:
   explicit MetricsMemoryDetails(const base::Closure& callback)
       : callback_(callback) {}
 
   virtual void OnDetailsAvailable() OVERRIDE {
@@ skipping 262 matching lines @@
 void MetricsService::BrowserChildProcessHostConnected(
     const content::ChildProcessData& data) {
   GetChildProcessStats(data).process_launches++;
 }
 
 void MetricsService::BrowserChildProcessCrashed(
     const content::ChildProcessData& data) {
   GetChildProcessStats(data).process_crashes++;
   // Exclude plugin crashes from the count below because we report them via
   // a separate UMA metric.
-  if (!IsPluginProcess(data.type))
+  if (!IsPluginProcess(data.process_type))
     IncrementPrefValue(prefs::kStabilityChildProcessCrashCount);
 }
 
 void MetricsService::BrowserChildProcessInstanceCreated(
     const content::ChildProcessData& data) {
   GetChildProcessStats(data).instances++;
 }
 
 void MetricsService::Observe(int type,
                              const content::NotificationSource& source,
@@ skipping 338 matching lines @@
 void MetricsService::OnUserAction(const std::string& action) {
   if (!CanLogNotification())
     return;
 
   log_manager_.current_log()->RecordUserAction(action.c_str());
   HandleIdleSinceLastTransmission(false);
 }
 
 void MetricsService::ReceivedProfilerData(
     const tracked_objects::ProcessDataSnapshot& process_data,
-    content::ProcessType process_type) {
+    int process_type) {
   DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
 
   // Upon the first callback, create the initial log so that we can immediately
   // save the profiler data.
   if (!initial_log_.get())
     initial_log_.reset(new MetricsLog(client_id_, session_id_));
 
   initial_log_->RecordProfilerData(process_data, process_type);
 }
 
@@ skipping 694 matching lines @@
     stats.process_type = content::PROCESS_TYPE_PLUGIN;
   } else {
     DCHECK(IsPluginProcess(stats.process_type));
   }
   stats.loading_errors++;
 }
 
 MetricsService::ChildProcessStats& MetricsService::GetChildProcessStats(
     const content::ChildProcessData& data) {
   const string16& child_name = data.name;
-  if (!ContainsKey(child_process_stats_buffer_, child_name))
-    child_process_stats_buffer_[child_name] = ChildProcessStats(data.type);
+  if (!ContainsKey(child_process_stats_buffer_, child_name)) {
+    child_process_stats_buffer_[child_name] =
+        ChildProcessStats(data.process_type);
+  }
   return child_process_stats_buffer_[child_name];
 }
 
 void MetricsService::LogKeywordCount(size_t keyword_count) {
   PrefService* pref = g_browser_process->local_state();
   DCHECK(pref);
   pref->SetInteger(prefs::kNumKeywords, static_cast<int>(keyword_count));
   ScheduleNextStateSave();
 }
 
@@ skipping 102 matching lines @@
   RecordCurrentState(pref);
 }
 
 void MetricsService::RecordCurrentState(PrefService* pref) {
   pref->SetInt64(prefs::kStabilityLastTimestampSec, Time::Now().ToTimeT());
 
   RecordPluginChanges(pref);
 }
 
 // static
-bool MetricsService::IsPluginProcess(content::ProcessType type) {
-  return (type == content::PROCESS_TYPE_PLUGIN ||
-          type == content::PROCESS_TYPE_PPAPI_PLUGIN ||
-          type == content::PROCESS_TYPE_PPAPI_BROKER);
+bool MetricsService::IsPluginProcess(int process_type) {
+  return (process_type == content::PROCESS_TYPE_PLUGIN ||
+          process_type == content::PROCESS_TYPE_PPAPI_PLUGIN ||
+          process_type == content::PROCESS_TYPE_PPAPI_BROKER);
 }
 
 #if defined(OS_CHROMEOS)
 void MetricsService::StartExternalMetrics() {
   external_metrics_ = new chromeos::ExternalMetrics;
   external_metrics_->Start();
 }
 #endif
 
 // static
 bool MetricsServiceHelper::IsMetricsReportingEnabled() {
   bool result = false;
   const PrefService* local_state = g_browser_process->local_state();
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }