Transmit a X-Chrome-UMA-Enabled bit to Google domains from clients that have UMA enabled.

chrome/browser/profiles/profile_io_data.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/profiles/profile_io_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 142 matching lines @@
 }
 
 }  // namespace
 
 void ProfileIOData::InitializeOnUIThread(Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   PrefService* pref_service = profile->GetPrefs();
 
   scoped_ptr<ProfileParams> params(new ProfileParams);
   params->path = profile->GetPath();
-  params->is_incognito = profile->IsOffTheRecord();
   params->clear_local_state_on_exit =
       pref_service->GetBoolean(prefs::kClearSiteDataOnExit);
 
   // Set up Accept-Language and Accept-Charset header values
   params->accept_language = net::HttpUtil::GenerateAcceptLanguageHeader(
       pref_service->GetString(prefs::kAcceptLanguages));
   std::string default_charset =
       pref_service->GetString(prefs::kGlobalDefaultCharset);
   params->accept_charset =
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
@@ skipping 66 matching lines @@
 
 void ProfileIOData::AppRequestContext::SetHttpTransactionFactory(
     net::HttpTransactionFactory* http_factory) {
   http_factory_.reset(http_factory);
   set_http_transaction_factory(http_factory);
 }
 
 ProfileIOData::AppRequestContext::~AppRequestContext() {}
 
 ProfileIOData::ProfileParams::ProfileParams()
-    : is_incognito(false),
-      clear_local_state_on_exit(false),
+    : clear_local_state_on_exit(false),
       io_thread(NULL),
 #if defined(ENABLE_NOTIFICATIONS)
       notification_service(NULL),
 #endif
       profile(NULL) {
 }
 
 ProfileIOData::ProfileParams::~ProfileParams() {}
 
 ProfileIOData::ProfileIOData(bool is_incognito)
     : initialized_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           resource_context_(new ResourceContext(this))),
-      initialized_on_UI_thread_(false) {
+      initialized_on_UI_thread_(false),
+      is_incognito_(is_incognito) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 ProfileIOData::~ProfileIOData() {
   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO))
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (main_request_context_)
     main_request_context_->AssertNoURLRequests();
   if (extensions_request_context_)
@@ skipping 182 matching lines @@
           io_thread->net_log(),
           io_thread_globals->proxy_script_fetcher_context.get(),
           profile_params_->proxy_config_service.release(),
           command_line));
 
   transport_security_state_.reset(new net::TransportSecurityState(
       command_line.GetSwitchValueASCII(switches::kHstsHosts)));
   transport_security_persister_.reset(
       new TransportSecurityPersister(transport_security_state_.get(),
                                      profile_params_->path,
-                                     profile_params_->is_incognito));
+                                     is_incognito()));
 
   // NOTE(willchan): Keep these protocol handlers in sync with
   // ProfileIOData::IsHandledProtocol().
   job_factory_.reset(new net::URLRequestJobFactory);
   if (profile_params_->protocol_handler_registry) {
     job_factory_->AddInterceptor(
         new ProtocolHandlerRegistryInterceptor(
             profile_params_->protocol_handler_registry));
   }
   bool set_protocol = job_factory_->SetProtocolHandler(
       chrome::kExtensionScheme,
-      CreateExtensionProtocolHandler(profile_params_->is_incognito,
+      CreateExtensionProtocolHandler(is_incognito(),
                                      profile_params_->extension_info_map));
   DCHECK(set_protocol);
   set_protocol = job_factory_->SetProtocolHandler(
       chrome::kChromeUIScheme,
       ChromeURLDataManagerBackend::CreateProtocolHandler(
           chrome_url_data_manager_backend_.get()));
   DCHECK(set_protocol);
   set_protocol = job_factory_->SetProtocolHandler(
       chrome::kChromeDevToolsScheme,
       CreateDevToolsProtocolHandler(chrome_url_data_manager_backend_.get()));
@@ skipping 17 matching lines @@
   resource_context_->request_context_ = main_request_context_;
 
   LazyInitializeInternal(profile_params_.get());
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ProfileIOData::ApplyProfileParamsToContext(
     ChromeURLRequestContext* context) const {
-  context->set_is_incognito(profile_params_->is_incognito);
+  context->set_is_incognito(is_incognito());
   context->set_accept_language(profile_params_->accept_language);
   context->set_accept_charset(profile_params_->accept_charset);
   context->set_referrer_charset(profile_params_->referrer_charset);
   context->set_ssl_config_service(profile_params_->ssl_config_service);
 }
 
 void ProfileIOData::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   enable_referrers_.Destroy();
+  enable_metrics_.Destroy();
   clear_local_state_on_exit_.Destroy();
   safe_browsing_enabled_.Destroy();
   session_startup_pref_.Destroy();
 #if defined(ENABLE_CONFIGURATION_POLICY)
   if (url_blacklist_manager_.get())
     url_blacklist_manager_->ShutdownOnUIThread();
 #endif
   bool posted = BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this);
   if (!posted)
     delete this;
 }
 
 void ProfileIOData::set_server_bound_cert_service(
     net::ServerBoundCertService* server_bound_cert_service) const {
   server_bound_cert_service_.reset(server_bound_cert_service);
 }
 
 void ProfileIOData::DestroyResourceContext() {
   resource_context_.reset();
 }