Convert implicit scoped_refptr constructor calls to explicit ones, part 1

chrome/browser/browser_main.cc

 // Copyright (c) 2010 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/browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 196 matching lines @@
 // This is an A/B test for the maximum number of persistent connections per
 // host. Currently Chrome, Firefox, and IE8 have this value set at 6. Safari
 // uses 4, and Fasterfox (a plugin for Firefox that supposedly configures it to
 // run faster) uses 8. We would like to see how much of an effect this value has
 // on browsing. Too large a value might cause us to run into SYN flood detection
 // mechanisms.
 void BrowserMainParts::ConnectionFieldTrial() {
   const base::FieldTrial::Probability kConnectDivisor = 100;
   const base::FieldTrial::Probability kConnectProbability = 1;  // 1% prob.
 
-  scoped_refptr<base::FieldTrial> connect_trial =
-      new base::FieldTrial("ConnCountImpact", kConnectDivisor);
+  scoped_refptr<base::FieldTrial> connect_trial(
+      new base::FieldTrial("ConnCountImpact", kConnectDivisor));
 
   const int connect_5 = connect_trial->AppendGroup("conn_count_5",
                                                    kConnectProbability);
   const int connect_7 = connect_trial->AppendGroup("conn_count_7",
                                                    kConnectProbability);
   const int connect_8 = connect_trial->AppendGroup("conn_count_8",
                                                    kConnectProbability);
   const int connect_9 = connect_trial->AppendGroup("conn_count_9",
                                                    kConnectProbability);
   // This (6) is the current default value. Having this group declared here
@@ skipping 23 matching lines @@
 // A/B test for determining a value for unused socket timeout. Currently the
 // timeout defaults to 10 seconds. Having this value set too low won't allow us
 // to take advantage of idle sockets. Setting it to too high could possibly
 // result in more ERR_CONNECT_RESETs, requiring one RTT to receive the RST
 // packet and possibly another RTT to re-establish the connection.
 void BrowserMainParts::SocketTimeoutFieldTrial() {
   const base::FieldTrial::Probability kIdleSocketTimeoutDivisor = 100;
   // 1% probability for all experimental settings.
   const base::FieldTrial::Probability kSocketTimeoutProbability = 1;
 
-  scoped_refptr<base::FieldTrial> socket_timeout_trial =
-      new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor);
+  scoped_refptr<base::FieldTrial> socket_timeout_trial(
+      new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor));
 
   const int socket_timeout_5 =
       socket_timeout_trial->AppendGroup("idle_timeout_5",
                                         kSocketTimeoutProbability);
   const int socket_timeout_10 =
       socket_timeout_trial->AppendGroup("idle_timeout_10",
                                         kSocketTimeoutProbability);
   const int socket_timeout_20 =
       socket_timeout_trial->AppendGroup("idle_timeout_20",
                                         kSocketTimeoutProbability);
@@ skipping 14 matching lines @@
   } else {
     NOTREACHED();
   }
 }
 
 void BrowserMainParts::ProxyConnectionsFieldTrial() {
   const base::FieldTrial::Probability kProxyConnectionsDivisor = 100;
   // 25% probability
   const base::FieldTrial::Probability kProxyConnectionProbability = 1;
 
-  scoped_refptr<base::FieldTrial> proxy_connection_trial =
-      new base::FieldTrial("ProxyConnectionImpact", kProxyConnectionsDivisor);
+  scoped_refptr<base::FieldTrial> proxy_connection_trial(
+      new base::FieldTrial("ProxyConnectionImpact", kProxyConnectionsDivisor));
 
   // The number of max sockets per group cannot be greater than the max number
   // of sockets per proxy server.  We tried using 8, and it can easily
   // lead to total browser stalls.
   const int proxy_connections_16 =
       proxy_connection_trial->AppendGroup("proxy_connections_16",
                                           kProxyConnectionProbability);
   const int proxy_connections_64 =
       proxy_connection_trial->AppendGroup("proxy_connections_64",
                                           kProxyConnectionProbability);
@@ skipping 29 matching lines @@
 void BrowserMainParts::SpdyFieldTrial() {
   bool is_spdy_trial = false;
   if (parsed_command_line().HasSwitch(switches::kUseSpdy)) {
     std::string spdy_mode =
         parsed_command_line().GetSwitchValueASCII(switches::kUseSpdy);
     net::HttpNetworkLayer::EnableSpdy(spdy_mode);
   } else {
     const base::FieldTrial::Probability kSpdyDivisor = 100;
     // 10% to preclude SPDY.
     base::FieldTrial::Probability npnhttp_probability = 10;
-    scoped_refptr<base::FieldTrial> trial =
-        new base::FieldTrial("SpdyImpact", kSpdyDivisor);
+    scoped_refptr<base::FieldTrial> trial(
+        new base::FieldTrial("SpdyImpact", kSpdyDivisor));
     // npn with only http support, no spdy.
     int npn_http_grp = trial->AppendGroup("npn_with_http", npnhttp_probability);
     // npn with spdy support.
     int npn_spdy_grp = trial->AppendGroup("npn_with_spdy",
         base::FieldTrial::kAllRemainingProbability);
     int trial_grp = trial->group();
     if (trial_grp == npn_http_grp) {
       is_spdy_trial = true;
       net::HttpNetworkLayer::EnableSpdy("npn-http");
     } else if (trial_grp == npn_spdy_grp) {
@@ skipping 16 matching lines @@
 // If neither --enable-content-prefetch or --disable-content-prefetch
 // is set, users will not be in an A/B test for prefetching.
 void BrowserMainParts::PrefetchFieldTrial() {
   if (parsed_command_line().HasSwitch(switches::kEnableContentPrefetch))
     ResourceDispatcherHost::set_is_prefetch_enabled(true);
   else if (parsed_command_line().HasSwitch(switches::kDisableContentPrefetch)) {
     ResourceDispatcherHost::set_is_prefetch_enabled(false);
   } else {
     const base::FieldTrial::Probability kPrefetchDivisor = 1000;
     const base::FieldTrial::Probability no_prefetch_probability = 500;
-    scoped_refptr<base::FieldTrial> trial =
-        new base::FieldTrial("Prefetch", kPrefetchDivisor);
+    scoped_refptr<base::FieldTrial> trial(
+        new base::FieldTrial("Prefetch", kPrefetchDivisor));
     trial->AppendGroup("ContentPrefetchDisabled", no_prefetch_probability);
     const int yes_prefetch_grp =
         trial->AppendGroup("ContentPrefetchEnabled",
                            base::FieldTrial::kAllRemainingProbability);
     const int trial_grp = trial->group();
     ResourceDispatcherHost::set_is_prefetch_enabled(
         trial_grp == yes_prefetch_grp);
   }
 }
 
 // If neither --enable-connect-backup-jobs or --disable-connect-backup-jobs is
 // specified, run an A/B test for automatically establishing backup TCP
 // connections when a certain timeout value is exceeded.
 void BrowserMainParts::ConnectBackupJobsFieldTrial() {
   if (parsed_command_line().HasSwitch(switches::kEnableConnectBackupJobs)) {
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         true);
   } else if (parsed_command_line().HasSwitch(
         switches::kDisableConnectBackupJobs)) {
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         false);
   } else {
     const base::FieldTrial::Probability kConnectBackupJobsDivisor = 100;
     // 1% probability.
     const base::FieldTrial::Probability kConnectBackupJobsProbability = 1;
-    scoped_refptr<base::FieldTrial> trial =
+    scoped_refptr<base::FieldTrial> trial(
         new base::FieldTrial("ConnnectBackupJobs",
-                             kConnectBackupJobsDivisor);
+                             kConnectBackupJobsDivisor));
     trial->AppendGroup("ConnectBackupJobsDisabled",
                        kConnectBackupJobsProbability);
     const int connect_backup_jobs_enabled =
         trial->AppendGroup("ConnectBackupJobsEnabled",
                            base::FieldTrial::kAllRemainingProbability);
     const int trial_group = trial->group();
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         trial_group == connect_backup_jobs_enabled);
   }
 }
@@ skipping 650 matching lines @@
   // TODO(viettrungluu): why don't we run this earlier?
   if (!parsed_command_line.HasSwitch(switches::kNoErrorDialogs))
     WarnAboutMinimumSystemRequirements();
 
   InitializeNetworkOptions(parsed_command_line);
 
   // Initialize histogram synchronizer system. This is a singleton and is used
   // for posting tasks via NewRunnableMethod. Its deleted when it goes out of
   // scope. Even though NewRunnableMethod does AddRef and Release, the object
   // will not be deleted after the Task is executed.
-  scoped_refptr<HistogramSynchronizer> histogram_synchronizer =
-      new HistogramSynchronizer();
+  scoped_refptr<HistogramSynchronizer> histogram_synchronizer(
+      new HistogramSynchronizer());
 
   // Initialize the prefs of the local state.
   browser::RegisterLocalState(local_state);
 
   // Now that all preferences have been registered, set the install date
   // for the uninstall metrics if this is our first run. This only actually
   // gets used if the user has metrics reporting enabled at uninstall time.
   int64 install_date =
       local_state->GetInt64(prefs::kUninstallMetricsInstallDate);
   if (install_date == 0) {
@@ skipping 282 matching lines @@
 
   // Do initialize the plug-in service (and related preferences).
   PluginService::InitGlobalInstance(profile);
 
   // Prepare for memory caching of SDCH dictionaries.
   // Perform A/B test to measure global impact of SDCH support.
   // Set up a field trial to see what disabling SDCH does to latency of page
   // layout globally.
   base::FieldTrial::Probability kSDCH_DIVISOR = 1000;
   base::FieldTrial::Probability kSDCH_DISABLE_PROBABILITY = 1;  // 0.1% prob.
-  scoped_refptr<base::FieldTrial> sdch_trial =
-      new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR);
+  scoped_refptr<base::FieldTrial> sdch_trial(
+      new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR));
 
   // Use default of "" so that all domains are supported.
   std::string sdch_supported_domain("");
   if (parsed_command_line.HasSwitch(switches::kSdchFilter)) {
     sdch_supported_domain =
         parsed_command_line.GetSwitchValueASCII(switches::kSdchFilter);
   } else {
     sdch_trial->AppendGroup("global_disable_sdch",
                             kSDCH_DISABLE_PROBABILITY);
     int sdch_enabled = sdch_trial->AppendGroup("global_enable_sdch",
@@ skipping 169 matching lines @@
   metrics->Stop();
 
   // browser_shutdown takes care of deleting browser_process, so we need to
   // release it.
   ignore_result(browser_process.release());
   browser_shutdown::Shutdown();
 
   TRACE_EVENT_END("BrowserMain", 0, 0);
   return result_code;
 }