[Chromecast] Moves persistent UMA client ID handling to common code.

chromecast/browser/metrics/cast_metrics_service_client.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 "chromecast/browser/metrics/cast_metrics_service_client.h"
 
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chromecast/base/cast_sys_info_util.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/base/path_utils.h"
 #include "chromecast/base/version.h"
+#include "chromecast/browser/cast_browser_process.h"
+#include "chromecast/browser/cast_content_browser_client.h"
 #include "chromecast/browser/metrics/cast_stability_metrics_provider.h"
-#include "chromecast/browser/metrics/platform_metrics_providers.h"
 #include "chromecast/common/pref_names.h"
 #include "chromecast/public/cast_sys_info.h"
 #include "components/metrics/client_info.h"
 #include "components/metrics/gpu/gpu_metrics_provider.h"
 #include "components/metrics/metrics_provider.h"
 #include "components/metrics/metrics_service.h"
 #include "components/metrics/metrics_state_manager.h"
 #include "components/metrics/net/net_metrics_log_uploader.h"
 #include "components/metrics/net/network_metrics_provider.h"
 #include "components/metrics/profiler/profiler_metrics_provider.h"
@@ skipping 56 matching lines @@
 }
 
 void CastMetricsServiceClient::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(kMetricsOldClientID, std::string());
 }
 
 void CastMetricsServiceClient::SetMetricsClientId(
     const std::string& client_id) {
   client_id_ = client_id;
   LOG(INFO) << "Metrics client ID set: " << client_id;
-  PlatformSetClientID(cast_service_, client_id);
+  shell::CastBrowserProcess::GetInstance()->browser_client()->
+      SetMetricsClientId(client_id);
 }
 
 void CastMetricsServiceClient::OnRecordingDisabled() {
 }
 
 void CastMetricsServiceClient::StoreClientInfo(
     const ::metrics::ClientInfo& client_info) {
   const std::string& client_id = client_info.client_id;
   DCHECK(client_id.empty() || base::IsValidGUID(client_id));
   // backup client_id or reset to empty.
   SetMetricsClientId(client_id);
 }
 
 scoped_ptr< ::metrics::ClientInfo> CastMetricsServiceClient::LoadClientInfo() {
   scoped_ptr< ::metrics::ClientInfo> client_info(new ::metrics::ClientInfo);
+  client_info_loaded_ = true;
 
   // kMetricsIsNewClientID would be missing if either the device was just
   // FDR'ed, or it is on pre-v1.2 build.
   if (!pref_service_->GetBoolean(prefs::kMetricsIsNewClientID)) {
     // If the old client id exists, the device must be on pre-v1.2 build,
     // instead of just being FDR'ed.
     if (!pref_service_->GetString(kMetricsOldClientID).empty()) {
       // Force old client id to be regenerated. See b/9487011.
       client_info->client_id = base::GenerateGUID();
       pref_service_->SetBoolean(prefs::kMetricsIsNewClientID, true);
       return client_info.Pass();
     }
     // else the device was just FDR'ed, pass through.
   }
 
-  const std::string client_id(GetPlatformClientID(cast_service_));
-  if (!client_id.empty() && base::IsValidGUID(client_id)) {
-    client_info->client_id = client_id;
+  if (!persisted_client_id_.empty() &&
+      base::IsValidGUID(persisted_client_id_)) {
+    client_info->client_id = persisted_client_id_;
     return client_info.Pass();
   } else {

[byungchul, 2015/08/19 21:11:20]

no else after return.

[gunsch, 2015/08/19 21:23:12]

Done.

-    if (client_id.empty()) {
+    if (persisted_client_id_.empty()) {
       LOG(WARNING) << "Empty client id from platform,"
                    << " assuming this is the first boot up of a new device.";
     } else {
-      LOG(ERROR) << "Invalid client id " << client_id << " from platform.";
+      LOG(ERROR) << "Invalid client id from platform: " << persisted_client_id_
+                 << " from platform.";
     }
     return scoped_ptr< ::metrics::ClientInfo>();
   }
 }
 
 bool CastMetricsServiceClient::IsOffTheRecordSessionActive() {
   // Chromecast behaves as "off the record" w/r/t recording browsing state,
   // but this value is about not disabling metrics because of it.
   return false;
 }
@@ skipping 103 matching lines @@
   }
 }
 
 CastMetricsServiceClient::CastMetricsServiceClient(
     base::TaskRunner* io_task_runner,
     PrefService* pref_service,
     net::URLRequestContextGetter* request_context)
     : io_task_runner_(io_task_runner),
       pref_service_(pref_service),
       cast_service_(nullptr),
+      client_info_loaded_(false),
 #if defined(OS_LINUX)
       external_metrics_(nullptr),
       platform_metrics_(nullptr),
 #endif  // defined(OS_LINUX)
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       request_context_(request_context) {
 }
 
 CastMetricsServiceClient::~CastMetricsServiceClient() {
 #if defined(OS_LINUX)
   DCHECK(!external_metrics_);
   DCHECK(!platform_metrics_);
 #endif  // defined(OS_LINUX)
 }
 
+void CastMetricsServiceClient::SetPersistedClientId(
+    const std::string& client_id) {
+  DCHECK(!client_info_loaded_)
+      << "Persisted client ID must be set before client info is loaded.";
+  persisted_client_id_ = client_id;
+}
+
 void CastMetricsServiceClient::Initialize(CastService* cast_service) {
   DCHECK(cast_service);
   DCHECK(!cast_service_);
   cast_service_ = cast_service;
 
   metrics_state_manager_ = ::metrics::MetricsStateManager::Create(
       pref_service_,
       base::Bind(&CastMetricsServiceClient::IsReportingEnabled,
                  base::Unretained(this)),
       base::Bind(&CastMetricsServiceClient::StoreClientInfo,
@@ skipping 22 matching lines @@
     metrics_service_->RegisterMetricsProvider(
         scoped_ptr< ::metrics::MetricsProvider>(
             new ::metrics::GPUMetricsProvider));
   }
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr< ::metrics::MetricsProvider>(
           new ::metrics::NetworkMetricsProvider(io_task_runner_)));
   metrics_service_->RegisterMetricsProvider(
       scoped_ptr< ::metrics::MetricsProvider>(
           new ::metrics::ProfilerMetricsProvider));
-  RegisterPlatformMetricsProviders(metrics_service_.get(), cast_service_);
+  shell::CastBrowserProcess::GetInstance()->browser_client()->
+      RegisterMetricsProviders(metrics_service_.get());
 
   metrics_service_->InitializeMetricsRecordingState();
 #if !defined(OS_ANDROID)
   // Reset clean_shutdown bit after InitializeMetricsRecordingState().
   metrics_service_->LogNeedForCleanShutdown();
 #endif  // !defined(OS_ANDROID)
 
   if (IsReportingEnabled())
     metrics_service_->Start();
 
@@ skipping 26 matching lines @@
 #endif  // defined(OS_LINUX)
   metrics_service_->Stop();
 }
 
 bool CastMetricsServiceClient::IsReportingEnabled() {
   return pref_service_->GetBoolean(prefs::kOptInStats);
 }
 
 }  // namespace metrics
 }  // namespace chromecast