Disable AutoImport: experiment and histogram for analysis.

chrome/browser/chrome_browser_main.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/chrome_browser_main.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 15 matching lines @@
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/task_scheduler/scheduler_worker_pool_params.h"
 #include "base/task_scheduler/switches.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
@@ skipping 152 matching lines @@
 #include "chromeos/settings/cros_settings_names.h"
 #endif  // defined(OS_CHROMEOS)
 
 // TODO(port): several win-only methods have been pulled out of this, but
 // BrowserMain() as a whole needs to be broken apart so that it's usable by
 // other platforms. For now, it's just a stub. This is a serious work in
 // progress and should not be taken as an indication of a real refactoring.
 
 #if defined(OS_WIN)
 #include "base/trace_event/trace_event_etw_export_win.h"
+#include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "chrome/app/file_pre_reader_win.h"
 #include "chrome/browser/chrome_browser_main_win.h"
 #include "chrome/browser/component_updater/caps_installer_win.h"
 #include "chrome/browser/component_updater/sw_reporter_installer_win.h"
 #include "chrome/browser/downgrade/user_data_downgrade.h"
 #include "chrome/browser/first_run/try_chrome_dialog_view.h"
 #include "chrome/browser/first_run/upgrade_util_win.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/ui/network_profile_bubble.h"
@@ skipping 65 matching lines @@
 
 #if defined(OS_WIN) || defined(OS_MACOSX) || \
     (defined(OS_LINUX) && !defined(OS_CHROMEOS))
 #include "chrome/browser/metrics/desktop_engagement/desktop_engagement_service.h"
 #endif
 
 using content::BrowserThread;
 
 namespace {
 
+// feature used to remove AutoImport on first run is default-off
+const base::Feature kFirstRunAutoImport{"FirstRunAutoImport",

[manzagop (departed), 2016/08/18 15:59:56]

I'd call it DisableFirstRunAutoImport, so it's accurate (although confusing)
that when the feature is disabled, the import is happening.

[gcomanici, 2016/08/19 16:04:30]

Done.

+                                        base::FEATURE_DISABLED_BY_DEFAULT};
+
 // A provider of Geolocation services to override AccessTokenStore.
 class ChromeGeolocationDelegate : public device::GeolocationDelegate {
  public:
   ChromeGeolocationDelegate() = default;
 
   scoped_refptr<device::AccessTokenStore> CreateAccessTokenStore() final {
     return new ChromeAccessTokenStore();
   }
 
  private:
@@ skipping 40 matching lines @@
 // |pool_descriptor| is a semi-colon separated value string with the following
 // items:
 // 1. Minimum Thread Count (int)
 // 2. Maximum Thread Count (int)
 // 3. Thread Count Multiplier (double)
 // 4. Thread Count Offset (int)
 // 5. Detach Time in Milliseconds (milliseconds)
 // Additional values may appear as necessary and will be ignored.
 WorkerPoolVariationValues StringToWorkerPoolVariationValues(
     const base::StringPiece pool_descriptor) {
-  const std::vector<std::string> tokens =
-      SplitString(pool_descriptor, ";",
-                  base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  const std::vector<std::string> tokens = SplitString(
+      pool_descriptor, ";", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   int minimum;
   int maximum;
   double multiplier;
   int offset;
   int detach_milliseconds;
   // Checking for a size greater than the expected amount allows us to be
   // forward compatible if we add more variation values.
-  if (tokens.size() >= 5 &&
-      base::StringToInt(tokens[0], &minimum) &&
+  if (tokens.size() >= 5 && base::StringToInt(tokens[0], &minimum) &&
       base::StringToInt(tokens[1], &maximum) &&
       base::StringToDouble(tokens[2], &multiplier) &&
       base::StringToInt(tokens[3], &offset) &&
       base::StringToInt(tokens[4], &detach_milliseconds)) {
     const int num_of_cores = base::SysInfo::NumberOfProcessors();
     const int threads = std::ceil<int>(num_of_cores * multiplier) + offset;
     WorkerPoolVariationValues values;
     values.threads = std::min(maximum, std::max(minimum, threads));
     values.detach_period =
         base::TimeDelta::FromMilliseconds(detach_milliseconds);
@@ skipping 32 matching lines @@
   }
 
   using ThreadPriority = base::ThreadPriority;
   using IORestriction = base::SchedulerWorkerPoolParams::IORestriction;
   struct SchedulerWorkerPoolPredefinedParams {
     const char* name;
     ThreadPriority priority_hint;
     IORestriction io_restriction;
   };
   static const SchedulerWorkerPoolPredefinedParams kAllPredefinedParams[] = {
-    {"Background", ThreadPriority::BACKGROUND, IORestriction::DISALLOWED},
-    {"BackgroundFileIO", ThreadPriority::BACKGROUND, IORestriction::ALLOWED},
-    {"Foreground", ThreadPriority::NORMAL, IORestriction::DISALLOWED},
-    {"ForegroundFileIO", ThreadPriority::NORMAL, IORestriction::ALLOWED},
+      {"Background", ThreadPriority::BACKGROUND, IORestriction::DISALLOWED},
+      {"BackgroundFileIO", ThreadPriority::BACKGROUND, IORestriction::ALLOWED},
+      {"Foreground", ThreadPriority::NORMAL, IORestriction::DISALLOWED},
+      {"ForegroundFileIO", ThreadPriority::NORMAL, IORestriction::ALLOWED},
   };
   static_assert(arraysize(kAllPredefinedParams) == WORKER_POOL_COUNT,
                 "Mismatched Worker Pool Types and Predefined Parameters");
 
   std::vector<base::SchedulerWorkerPoolParams> params_vector;
   for (const auto& predefined_params : kAllPredefinedParams) {
     const auto pair = variation_params.find(predefined_params.name);
     if (pair == variation_params.end()) {
       DLOG(ERROR) << "Missing Worker Pool Configuration: "
                   << predefined_params.name;
       return;
     }
 
     const WorkerPoolVariationValues variation_values =
         StringToWorkerPoolVariationValues(pair->second);
 
     if (variation_values.threads <= 0 ||
         variation_values.detach_period.is_zero()) {
-      DLOG(ERROR) << "Invalid Worker Pool Configuration: " <<
-          predefined_params.name << " [" << pair->second << "]";
+      DLOG(ERROR) << "Invalid Worker Pool Configuration: "
+                  << predefined_params.name << " [" << pair->second << "]";
       return;
     }
 
-    params_vector.emplace_back(predefined_params.name,
-                               predefined_params.priority_hint,
-                               predefined_params.io_restriction,
-                               variation_values.threads,
-                               variation_values.detach_period);
+    params_vector.emplace_back(
+        predefined_params.name, predefined_params.priority_hint,
+        predefined_params.io_restriction, variation_values.threads,
+        variation_values.detach_period);
   }
 
   DCHECK_EQ(WORKER_POOL_COUNT, params_vector.size());
 
   base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
       params_vector, base::Bind(WorkerPoolIndexForTraits));
 }
 
 // Returns the new local state object, guaranteed non-NULL.
 // |local_state_task_runner| must be a shutdown-blocking task runner.
@@ skipping 115 matching lines @@
   // missing code in the above test.
   CHECK(profile) << "Cannot get default profile.";
 
 #else
   profile = GetStartupProfile(user_data_dir, parsed_command_line);
 
   if (!profile && !profile_dir_specified)
     profile = GetFallbackStartupProfile();
 
   if (!profile) {
-    ProfileErrorType error_type = profile_dir_specified ?
-                                  PROFILE_ERROR_CREATE_FAILURE_SPECIFIED :
-                                  PROFILE_ERROR_CREATE_FAILURE_ALL;
+    ProfileErrorType error_type = profile_dir_specified
+                                      ? PROFILE_ERROR_CREATE_FAILURE_SPECIFIED
+                                      : PROFILE_ERROR_CREATE_FAILURE_ALL;
 
     // TODO(lwchkg): What diagnostics do you want to include in the feedback
     // report when an error occurs?
     ShowProfileErrorDialog(error_type, IDS_COULDNT_STARTUP_PROFILE_ERROR,
                            "Error creating primary profile.");
     return nullptr;
   }
 #endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID)
 
-  UMA_HISTOGRAM_LONG_TIMES(
-      "Startup.CreateFirstProfile", base::Time::Now() - start);
+  UMA_HISTOGRAM_LONG_TIMES("Startup.CreateFirstProfile",
+                           base::Time::Now() - start);
   return profile;
 }
 
 #if defined(OS_MACOSX)
 OSStatus KeychainCallback(SecKeychainEvent keychain_event,
-                          SecKeychainCallbackInfo* info, void* context) {
+                          SecKeychainCallbackInfo* info,
+                          void* context) {
   return noErr;
 }
 #endif  // defined(OS_MACOSX)
 
 void RegisterComponentsForUpdate() {
   component_updater::ComponentUpdateService* cus =
       g_browser_process->component_updater();
 
-  // Registration can be before or after cus->Start() so it is ok to post
-  // a task to the UI thread to do registration once you done the necessary
-  // file IO to know you existing component version.
+// Registration can be before or after cus->Start() so it is ok to post
+// a task to the UI thread to do registration once you done the necessary
+// file IO to know you existing component version.
 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
   RegisterRecoveryComponent(cus, g_browser_process->local_state());
   RegisterPepperFlashComponent(cus);
   RegisterSwiftShaderComponent(cus);
   RegisterWidevineCdmComponent(cus);
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_ANDROID)
 
 #if !defined(DISABLE_NACL) && !defined(OS_ANDROID)
 #if defined(OS_CHROMEOS)
   // PNaCl on Chrome OS is on rootfs and there is no need to download it. But
@@ skipping 56 matching lines @@
     std::string start_time_string =
         command_line.GetSwitchValueASCII(switches::kOriginalProcessStartTime);
     int64_t remote_start_time;
     if (base::StringToInt64(start_time_string, &remote_start_time)) {
       base::TimeDelta elapsed =
           base::Time::Now() - base::Time::FromInternalValue(remote_start_time);
       if (command_line.HasSwitch(switches::kFastStart)) {
         UMA_HISTOGRAM_LONG_TIMES(
             "Startup.WarmStartTimeFromRemoteProcessStartFast", elapsed);
       } else {
-        UMA_HISTOGRAM_LONG_TIMES(
-            "Startup.WarmStartTimeFromRemoteProcessStart", elapsed);
+        UMA_HISTOGRAM_LONG_TIMES("Startup.WarmStartTimeFromRemoteProcessStart",
+                                 elapsed);
       }
     }
   }
 
   g_browser_process->platform_part()->PlatformSpecificCommandLineProcessing(
       command_line);
 
   base::FilePath user_data_dir =
       g_browser_process->profile_manager()->user_data_dir();
   base::FilePath startup_profile_dir =
@@ skipping 105 matching lines @@
   if (parameters.ui_task)
     browser_defaults::enable_help_app = false;
 
   // Chrome disallows cookies by default. All code paths that want to use
   // cookies need to go through one of Chrome's URLRequestContexts which have
   // a ChromeNetworkDelegate attached that selectively allows cookies again.
   net::URLRequest::SetDefaultCookiePolicyToBlock();
 }
 
 ChromeBrowserMainParts::~ChromeBrowserMainParts() {
-  for (int i = static_cast<int>(chrome_extra_parts_.size())-1; i >= 0; --i)
+  for (int i = static_cast<int>(chrome_extra_parts_.size()) - 1; i >= 0; --i)
     delete chrome_extra_parts_[i];
   chrome_extra_parts_.clear();
 }
 
 // This will be called after the command-line has been mutated by about:flags
 void ChromeBrowserMainParts::SetupMetricsAndFieldTrials() {
   TRACE_EVENT0("startup", "ChromeBrowserMainParts::SetupMetricsAndFieldTrials");
   // Must initialize metrics after labs have been converted into switches,
   // but before field trials are set up (so that client ID is available for
   // one-time randomized field trials).
@@ skipping 35 matching lines @@
     CHECK(result) << "Invalid --" << switches::kForceFieldTrials
                   << " list specified.";
   }
 
   std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
 
   // Associate parameters chosen in about:flags and create trial/group for them.
   flags_ui::PrefServiceFlagsStorage flags_storage(
       g_browser_process->local_state());
   std::vector<std::string> variation_ids =
-      about_flags::RegisterAllFeatureVariationParameters(
-          &flags_storage, feature_list.get());
+      about_flags::RegisterAllFeatureVariationParameters(&flags_storage,
+                                                         feature_list.get());
 
   variations::VariationsHttpHeaderProvider* http_header_provider =
       variations::VariationsHttpHeaderProvider::GetInstance();
   // Force the variation ids selected in chrome://flags and/or specified using
   // the command-line flag.
   bool result = http_header_provider->ForceVariationIds(
       command_line->GetSwitchValueASCII(switches::kForceVariationIds),
       &variation_ids);
   CHECK(result) << "Invalid list of variation ids specified (either in --"
                 << switches::kForceVariationIds << " or in chrome://flags)";
@@ skipping 223 matching lines @@
   run_message_loop_ = false;
 #if !defined(OS_ANDROID)
   chrome::MaybeShowInvalidUserDataDirWarningDialog();
 #endif  // !defined(OS_ANDROID)
   if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir_))
     return chrome::RESULT_CODE_MISSING_DATA;
 
   // Force MediaCaptureDevicesDispatcher to be created on UI thread.
   MediaCaptureDevicesDispatcher::GetInstance();
 
-  // Android's first run is done in Java instead of native.
+// Android's first run is done in Java instead of native.
 #if !defined(OS_ANDROID)
   process_singleton_.reset(new ChromeProcessSingleton(
       user_data_dir_, base::Bind(&ProcessSingletonNotificationCallback)));
 
   // Cache first run state early.
   first_run::IsChromeFirstRun();
 #endif  // !defined(OS_ANDROID)
 
   scoped_refptr<base::SequencedTaskRunner> local_state_task_runner =
       JsonPrefStore::GetTaskRunnerForFile(
           base::FilePath(chrome::kLocalStorePoolName),
           BrowserThread::GetBlockingPool());
 
   {
-    TRACE_EVENT0("startup",
-      "ChromeBrowserMainParts::PreCreateThreadsImpl:InitBrowswerProcessImpl");
+    TRACE_EVENT0(
+        "startup",
+        "ChromeBrowserMainParts::PreCreateThreadsImpl:InitBrowswerProcessImpl");
     browser_process_.reset(new BrowserProcessImpl(local_state_task_runner.get(),
                                                   parsed_command_line()));
   }
 
   if (parsed_command_line().HasSwitch(switches::kEnableProfiling)) {
     TRACE_EVENT0("startup",
-        "ChromeBrowserMainParts::PreCreateThreadsImpl:InitProfiling");
+                 "ChromeBrowserMainParts::PreCreateThreadsImpl:InitProfiling");
     // User wants to override default tracking status.
     std::string flag =
-      parsed_command_line().GetSwitchValueASCII(switches::kEnableProfiling);
+        parsed_command_line().GetSwitchValueASCII(switches::kEnableProfiling);
     // Default to basic profiling (no parent child support).
     tracked_objects::ThreadData::Status status =
-          tracked_objects::ThreadData::PROFILING_ACTIVE;
+        tracked_objects::ThreadData::PROFILING_ACTIVE;
     if (flag.compare("0") != 0)
       status = tracked_objects::ThreadData::DEACTIVATED;
     tracked_objects::ThreadData::InitializeAndSetTrackingStatus(status);
   }
 
-  local_state_ = InitializeLocalState(
-      local_state_task_runner.get(), parsed_command_line());
+  local_state_ = InitializeLocalState(local_state_task_runner.get(),
+                                      parsed_command_line());
 
 #if !defined(OS_ANDROID)
   // These members must be initialized before returning from this function.
   master_prefs_.reset(new first_run::MasterPrefs);
   // Android doesn't use StartupBrowserCreator.
   browser_creator_.reset(new StartupBrowserCreator);
   // TODO(yfriedman): Refactor Android to re-use UMABrowsingActivityObserver
   chrome::UMABrowsingActivityObserver::Init();
 #endif  // !defined(OS_ANDROID)
 
 #if !defined(OS_CHROMEOS)
   // Convert active labs into switches. This needs to be done before
   // ResourceBundle::InitSharedInstanceWithLocale as some loaded resources are
   // affected by experiment flags (--touch-optimized-ui in particular).
   // On ChromeOS system level flags are applied from the device settings from
   // the session manager.
   {
     TRACE_EVENT0("startup",
-        "ChromeBrowserMainParts::PreCreateThreadsImpl:ConvertFlags");
+                 "ChromeBrowserMainParts::PreCreateThreadsImpl:ConvertFlags");
     flags_ui::PrefServiceFlagsStorage flags_storage(
         g_browser_process->local_state());
     about_flags::ConvertFlagsToSwitches(&flags_storage,
                                         base::CommandLine::ForCurrentProcess(),
                                         flags_ui::kAddSentinels);
   }
 #endif  // !defined(OS_CHROMEOS)
   // The MaterialDesignController needs to look at command line flags, which
   // are not available until this point. Now that they are, proceed with
   // initializing the MaterialDesignController.
@@ skipping 15 matching lines @@
 #endif  // OS_WIN
 
   local_state_->UpdateCommandLinePrefStore(
       new CommandLinePrefStore(base::CommandLine::ForCurrentProcess()));
 
   // Reset the command line in the crash report details, since we may have
   // just changed it to include experiments.
   crash_keys::SetCrashKeysFromCommandLine(
       *base::CommandLine::ForCurrentProcess());
 
-  // Mac starts it earlier in |PreMainMessageLoopStart()| (because it is
-  // needed when loading the MainMenu.nib and the language doesn't depend on
-  // anything since it comes from Cocoa.
+// Mac starts it earlier in |PreMainMessageLoopStart()| (because it is
+// needed when loading the MainMenu.nib and the language doesn't depend on
+// anything since it comes from Cocoa.
 #if defined(OS_MACOSX)
   std::string locale =
       parameters().ui_task ? "en-US" : l10n_util::GetLocaleOverride();
   browser_process_->SetApplicationLocale(locale);
 #else
-  const std::string locale =
-      local_state_->GetString(prefs::kApplicationLocale);
+  const std::string locale = local_state_->GetString(prefs::kApplicationLocale);
 
   // On a POSIX OS other than ChromeOS, the parameter that is passed to the
   // method InitSharedInstance is ignored.
 
-  TRACE_EVENT_BEGIN0("startup",
+  TRACE_EVENT_BEGIN0(
+      "startup",
       "ChromeBrowserMainParts::PreCreateThreadsImpl:InitResourceBundle");
   const std::string loaded_locale =
       ui::ResourceBundle::InitSharedInstanceWithLocale(
           locale, NULL, ui::ResourceBundle::LOAD_COMMON_RESOURCES);
-  TRACE_EVENT_END0("startup",
+  TRACE_EVENT_END0(
+      "startup",
       "ChromeBrowserMainParts::PreCreateThreadsImpl:InitResourceBundle");
 
   if (loaded_locale.empty() &&
       !parsed_command_line().HasSwitch(switches::kNoErrorDialogs)) {
     ShowMissingLocaleMessageBox();
     return chrome::RESULT_CODE_MISSING_DATA;
   }
   CHECK(!loaded_locale.empty()) << "Locale could not be found for " << locale;
   browser_process_->SetApplicationLocale(loaded_locale);
 
   {
     TRACE_EVENT0("startup",
-        "ChromeBrowserMainParts::PreCreateThreadsImpl:AddDataPack");
+                 "ChromeBrowserMainParts::PreCreateThreadsImpl:AddDataPack");
     base::FilePath resources_pack_path;
     PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path);
 #if defined(OS_ANDROID)
     ui::LoadMainAndroidPackFile("assets/resources.pak", resources_pack_path);
 #else
     ResourceBundle::GetSharedInstance().AddDataPackFromPath(
         resources_pack_path, ui::SCALE_FACTOR_NONE);
 #endif  // defined(OS_ANDROID)
   }
 #endif  // defined(OS_MACOSX)
@@ skipping 186 matching lines @@
 
 namespace {
 
 void WINAPI SyzyASANExperimentCallback(const char* name, const char* group) {
   // Indirect through the function above, so that the friend declaration doesn't
   // need the ugly calling convention.
   SyzyASANRegisterExperiment(name, group);
 }
 
 void SetupSyzyASAN() {
-  typedef VOID(WINAPI* SyzyASANExperimentCallbackFn)(const char* name,
-                                                     const char* group);
-  typedef VOID(WINAPI* SyzyASANEnumExperimentsFn)(SyzyASANExperimentCallbackFn);
+  typedef VOID(WINAPI * SyzyASANExperimentCallbackFn)(const char* name,
+                                                      const char* group);
+  typedef VOID(WINAPI *
+               SyzyASANEnumExperimentsFn)(SyzyASANExperimentCallbackFn);
   HMODULE syzyasan_handle = ::GetModuleHandle(L"syzyasan_rtl.dll");
   if (!syzyasan_handle)
     return;
 
   // Export the SyzyASAN experiments as synthetic field trials.
   SyzyASANEnumExperimentsFn syzyasan_enum_experiments =
       reinterpret_cast<SyzyASANEnumExperimentsFn>(
-            ::GetProcAddress(syzyasan_handle, "asan_EnumExperiments"));
+          ::GetProcAddress(syzyasan_handle, "asan_EnumExperiments"));
   if (syzyasan_enum_experiments) {
     syzyasan_enum_experiments(&SyzyASANExperimentCallback);
   }
 
   // Enable the deferred free mechanism in the syzyasan module, which helps the
   // performance by deferring some work on the critical path to a background
   // thread.
   if (base::FeatureList::IsEnabled(features::kSyzyasanDeferredFree)) {
     typedef VOID(WINAPI * SyzyasanEnableDeferredFreeThreadFunc)(VOID);
     bool success = false;
     SyzyasanEnableDeferredFreeThreadFunc syzyasan_enable_deferred_free =
         reinterpret_cast<SyzyasanEnableDeferredFreeThreadFunc>(
-            ::GetProcAddress(syzyasan_handle,
-                             "asan_EnableDeferredFreeThread"));
+            ::GetProcAddress(syzyasan_handle, "asan_EnableDeferredFreeThread"));
     if (syzyasan_enable_deferred_free) {
       syzyasan_enable_deferred_free();
       success = true;
     }
     UMA_HISTOGRAM_BOOLEAN("Syzyasan.DeferredFreeWasEnabled", success);
   }
 }
 
 }  // namespace
 
 #endif  // SYZYASAN
 
-
 void ChromeBrowserMainParts::PreBrowserStart() {
   TRACE_EVENT0("startup", "ChromeBrowserMainParts::PreBrowserStart");
   for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
     chrome_extra_parts_[i]->PreBrowserStart();
 
   three_d_observer_.reset(new ThreeDAPIObserver());
 
 #if defined(SYZYASAN)
   SetupSyzyASAN();
 #endif
@@ skipping 10 matching lines @@
   for (size_t i = 0; i < chrome_extra_parts_.size(); ++i)
     chrome_extra_parts_[i]->PostBrowserStart();
 #if !defined(OS_ANDROID)
   // Allow ProcessSingleton to process messages.
   process_singleton_->Unlock();
 #endif  // !defined(OS_ANDROID)
 #if defined(ENABLE_WEBRTC)
   // Set up a task to delete old WebRTC log files for all profiles. Use a delay
   // to reduce the impact on startup time.
   BrowserThread::PostDelayedTask(
-      BrowserThread::UI,
-      FROM_HERE,
+      BrowserThread::UI, FROM_HERE,
       base::Bind(&WebRtcLogUtil::DeleteOldWebRtcLogFilesForAllProfiles),
       base::TimeDelta::FromMinutes(1));
 #endif  // defined(ENABLE_WEBRTC)
 
 #if !defined(OS_ANDROID)
   // WebUSB is an experimental web API. The sites these notifications will link
   // to will only work if the experiment is enabled and WebUSB feature is
   // enabled.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalWebPlatformFeatures) &&
@@ skipping 28 matching lines @@
                    installer::GetModulePath(installer::kChromeChildDll),
                    pre_read_options));
   }
 
   // Windows parental controls calls can be slow, so we do an early init here
   // that calculates this value off of the UI thread.
   IncognitoModePrefs::InitializePlatformParentalControls();
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
-  if (!variations::GetVariationParamValue(
-      "LightSpeed", "EarlyInitStartup").empty()) {
+  if (!variations::GetVariationParamValue("LightSpeed", "EarlyInitStartup")
+           .empty()) {
     // Try to compute this early on another thread so that we don't spend time
     // during profile load initializing the extensions APIs.
-    BrowserThread::PostTask(
-        BrowserThread::FILE_USER_BLOCKING,
-        FROM_HERE,
-        base::Bind(
-            base::IgnoreResult(&extensions::FeatureProvider::GetAPIFeatures)));
+    BrowserThread::PostTask(BrowserThread::FILE_USER_BLOCKING, FROM_HERE,
+                            base::Bind(base::IgnoreResult(
+                                &extensions::FeatureProvider::GetAPIFeatures)));
   }
 #endif
 
-  // Android updates the metrics service dynamically depending on whether the
-  // application is in the foreground or not. Do not start here.
+// Android updates the metrics service dynamically depending on whether the
+// application is in the foreground or not. Do not start here.
 #if !defined(OS_ANDROID)
   // Now that the file thread has been started, start recording.
   StartMetricsRecording();
 #endif  // !defined(OS_ANDROID)
 
   if (!base::debug::BeingDebugged()) {
     // Create watchdog thread after creating all other threads because it will
     // watch the other threads and they must be running.
     browser_process_->watchdog_thread();
   }
@@ skipping 12 matching lines @@
   bool already_running = browser_util::IsBrowserAlreadyRunning();
 
   // If the command line specifies 'uninstall' then we need to work here
   // unless we detect another chrome browser running.
   if (parsed_command_line().HasSwitch(switches::kUninstall)) {
     return DoUninstallTasks(already_running);
   }
 
   if (parsed_command_line().HasSwitch(switches::kHideIcons) ||
       parsed_command_line().HasSwitch(switches::kShowIcons)) {
-    return ChromeBrowserMainPartsWin::HandleIconsCommands(
-        parsed_command_line_);
+    return ChromeBrowserMainPartsWin::HandleIconsCommands(parsed_command_line_);
   }
 
   ui::SelectFileDialog::SetFactory(new ChromeSelectFileDialogFactory(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 #endif  // defined(OS_WIN)
 
   if (parsed_command_line().HasSwitch(switches::kMakeDefaultBrowser)) {
     bool is_managed = g_browser_process->local_state()->IsManagedPreference(
         prefs::kDefaultBrowserSettingEnabled);
-    if (is_managed && !g_browser_process->local_state()->GetBoolean(
-        prefs::kDefaultBrowserSettingEnabled)) {
+    if (is_managed &&
+        !g_browser_process->local_state()->GetBoolean(
+            prefs::kDefaultBrowserSettingEnabled)) {
       return static_cast<int>(chrome::RESULT_CODE_ACTION_DISALLOWED_BY_POLICY);
     }
 
     return shell_integration::SetAsDefaultBrowser()
                ? static_cast<int>(content::RESULT_CODE_NORMAL_EXIT)
                : static_cast<int>(chrome::RESULT_CODE_SHELL_INTEGRATION_FAILED);
   }
 
 #if defined(USE_AURA)
   // Make sure aura::Env has been initialized.
   CHECK(aura::Env::GetInstance());
 #endif  // defined(USE_AURA)
 
-  // Android doesn't support extensions and doesn't implement ProcessSingleton.
+// Android doesn't support extensions and doesn't implement ProcessSingleton.
 #if !defined(OS_ANDROID)
   // If the command line specifies --pack-extension, attempt the pack extension
   // startup action and exit.
   if (parsed_command_line().HasSwitch(switches::kPackExtension)) {
     extensions::StartupHelper extension_startup_helper;
     if (extension_startup_helper.PackExtension(parsed_command_line()))
       return content::RESULT_CODE_NORMAL_EXIT;
     return chrome::RESULT_CODE_PACK_EXTENSION_ERROR;
   }
 
   // When another process is running, use that process instead of starting a
   // new one. NotifyOtherProcess will currently give the other process up to
   // 20 seconds to respond. Note that this needs to be done before we attempt
   // to read the profile.
   notify_result_ = process_singleton_->NotifyOtherProcessOrCreate();
   switch (notify_result_) {
     case ProcessSingleton::PROCESS_NONE:
       // No process already running, fall through to starting a new one.
       break;
 
     case ProcessSingleton::PROCESS_NOTIFIED:
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
       // On POSIX systems, print a message notifying the process is running.
-      printf("%s\n", base::SysWideToNativeMB(base::UTF16ToWide(
-          l10n_util::GetStringUTF16(IDS_USED_EXISTING_BROWSER))).c_str());
+      printf("%s\n", base::SysWideToNativeMB(
+                         base::UTF16ToWide(l10n_util::GetStringUTF16(
+                             IDS_USED_EXISTING_BROWSER)))
+                         .c_str());
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 
       // Having a differentiated return type for testing allows for tests to
       // verify proper handling of some switches. When not testing, stick to
       // the standard Unix convention of returning zero when things went as
       // expected.
       if (parsed_command_line().HasSwitch(switches::kTestType))
         return chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED;
       return content::RESULT_CODE_NORMAL_EXIT;
 
@@ skipping 70 matching lines @@
 
   metrics::MetricsService::SetExecutionPhase(
       metrics::MetricsService::CREATE_PROFILE,
       g_browser_process->local_state());
 
   UMA_HISTOGRAM_TIMES("Startup.PreMainMessageLoopRunImplStep1Time",
                       base::TimeTicks::Now() - start_time_step1);
 
   // This step is costly and is already measured in Startup.CreateFirstProfile
   // and more directly Profile.CreateAndInitializeProfile.
-  profile_ = CreatePrimaryProfile(parameters(),
-                                  user_data_dir_,
-                                  parsed_command_line());
+  profile_ =
+      CreatePrimaryProfile(parameters(), user_data_dir_, parsed_command_line());
   if (!profile_)
     return content::RESULT_CODE_NORMAL_EXIT;
 
 #if !defined(OS_ANDROID)
   const base::TimeTicks start_time_step2 = base::TimeTicks::Now();
   // The first run sentinel must be created after the process singleton was
   // grabbed and no early return paths were otherwise hit above.
   first_run::CreateSentinelIfNeeded();
 #endif  // !defined(OS_ANDROID)
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
   // Autoload any profiles which are running background apps.
   // TODO(rlp): Do this on a separate thread. See http://crbug.com/99075.
   browser_process_->profile_manager()->AutoloadProfiles();
 #endif  // BUILDFLAG(ENABLE_BACKGROUND)
   // Post-profile init ---------------------------------------------------------
 
   TranslateService::Initialize();
 
   // Needs to be done before PostProfileInit, since login manager on CrOS is
   // called inside PostProfileInit.
   content::WebUIControllerFactory::RegisterFactory(
       ChromeWebUIControllerFactory::GetInstance());
 
-  // NaClBrowserDelegateImpl is accessed inside PostProfileInit().
-  // So make sure to create it before that.
+// NaClBrowserDelegateImpl is accessed inside PostProfileInit().
+// So make sure to create it before that.
 #if !defined(DISABLE_NACL)
   NaClBrowserDelegateImpl* delegate =
       new NaClBrowserDelegateImpl(browser_process_->profile_manager());
   nacl::NaClBrowser::SetDelegate(delegate);
 #endif  // !defined(DISABLE_NACL)
 
   // TODO(stevenjb): Move WIN and MACOSX specific code to appropriate Parts.
   // (requires supporting early exit).
   PostProfileInit();
 
 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
   // Show the First Run UI if this is the first time Chrome has been run on
   // this computer, or we're being compelled to do so by a command line flag.
   // Note that this be done _after_ the PrefService is initialized and all
   // preferences are registered, since some of the code that the importer
   // touches reads preferences.
   if (first_run::IsChromeFirstRun()) {
-    first_run::AutoImport(profile_,
-                          master_prefs_->homepage_defined,
-                          master_prefs_->do_import_items,
-                          master_prefs_->dont_import_items,
-                          master_prefs_->import_bookmarks_path);
+    // By default, autoImport is performed on first run.
+    bool perform_autoImport_on_first_run = true;
+// A field trial that is designed to turn off the AutoImport feature
+// for Windows users (on first run).
+// The feature keeps running for enterprise.
+#if defined(OS_WIN)
+    base::FieldTrial* trial = base::FieldTrialList::Find("FirstRunAutoImport");
+    perform_autoImport_on_first_run =
+        !trial || !base::FeatureList::IsEnabled(kFirstRunAutoImport) ||
+        base::win::IsEnrolledToDomain();
+#endif
+    if (perform_autoImport_on_first_run) {
+      first_run::AutoImport(profile_, master_prefs_->homepage_defined,
+                            master_prefs_->do_import_items,
+                            master_prefs_->dont_import_items,
+                            master_prefs_->import_bookmarks_path);
+    }
 
     // Note: this can pop the first run consent dialog on linux.
     first_run::DoPostImportTasks(profile_,
                                  master_prefs_->make_chrome_default_for_user);
 
     if (!master_prefs_->suppress_first_run_default_browser_prompt) {
       browser_creator_->set_show_main_browser_window(
           !chrome::ShowFirstRunDefaultBrowserPrompt(profile_));
     } else {
       browser_creator_->set_is_default_browser_dialog_suppressed(true);
@@ skipping 14 matching lines @@
   // but should run on startup if extended to handle crashes/hangs/patches.
   // Also, better to run once here than once for each HWND's WM_QUERYENDSESSION.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     ChromeBrowserMainPartsWin::RegisterApplicationRestart(
         parsed_command_line());
   }
 
   // Verify that the profile is not on a network share and if so prepare to show
   // notification to the user.
   if (NetworkProfileBubble::ShouldCheckNetworkProfile(profile_)) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
         base::Bind(&NetworkProfileBubble::CheckNetworkProfile,
                    profile_->GetPath()));
   }
 #endif  // defined(OS_WIN)
 
 #if defined(ENABLE_RLZ) && !defined(OS_CHROMEOS)
   // Init the RLZ library. This just binds the dll and schedules a task on the
   // file thread to be run sometime later. If this is the first run we record
   // the installation event.
   PrefService* pref_service = profile_->GetPrefs();
-  int ping_delay = first_run::IsChromeFirstRun() ? master_prefs_->ping_delay :
-      pref_service->GetInteger(first_run::GetPingDelayPrefName().c_str());
+  int ping_delay =
+      first_run::IsChromeFirstRun()
+          ? master_prefs_->ping_delay
+          : pref_service->GetInteger(first_run::GetPingDelayPrefName().c_str());
   // Negative ping delay means to send ping immediately after a first search is
   // recorded.
   rlz::RLZTracker::SetRlzDelegate(
       base::WrapUnique(new ChromeRLZTrackerDelegate));
   rlz::RLZTracker::InitRlzDelayed(
       first_run::IsChromeFirstRun(), ping_delay < 0,
       base::TimeDelta::FromMilliseconds(abs(ping_delay)),
       ChromeRLZTrackerDelegate::IsGoogleDefaultSearch(profile_),
       ChromeRLZTrackerDelegate::IsGoogleHomepage(profile_),
       ChromeRLZTrackerDelegate::IsGoogleInStartpages(profile_));
@@ skipping 35 matching lines @@
       browser_process_->GetApplicationLocale());
 
   // Start watching for hangs during startup. We disarm this hang detector when
   // ThreadWatcher takes over or when browser is shutdown or when
   // startup_watcher_ is deleted.
   metrics::MetricsService::SetExecutionPhase(
       metrics::MetricsService::STARTUP_TIMEBOMB_ARM,
       g_browser_process->local_state());
   startup_watcher_->Arm(base::TimeDelta::FromSeconds(600));
 
-  // On mobile, need for clean shutdown arises only when the application comes
-  // to foreground (i.e. MetricsService::OnAppEnterForeground is called).
-  // http://crbug.com/179143
+// On mobile, need for clean shutdown arises only when the application comes
+// to foreground (i.e. MetricsService::OnAppEnterForeground is called).
+// http://crbug.com/179143
 #if !defined(OS_ANDROID)
   // Start watching for a hang.
   browser_process_->metrics_service()->LogNeedForCleanShutdown();
 #endif  // !defined(OS_ANDROID)
 
 #if defined(ENABLE_PRINT_PREVIEW)
   // Create the instance of the cloud print proxy service so that it can launch
   // the service process if needed. This is needed because the service process
   // might have shutdown because an update was available.
   // TODO(torne): this should maybe be done with
   // BrowserContextKeyedServiceFactory::ServiceIsCreatedWithBrowserContext()
   // instead?
   CloudPrintProxyServiceFactory::GetForProfile(profile_);
 #endif  // defined(ENABLE_PRINT_PREVIEW)
 
   // Start watching all browser threads for responsiveness.
   metrics::MetricsService::SetExecutionPhase(
       metrics::MetricsService::THREAD_WATCHER_START,
       g_browser_process->local_state());
   ThreadWatcherList::StartWatchingAll(parsed_command_line());
 
 #if defined(OS_ANDROID)
   ThreadWatcherAndroid::RegisterApplicationStatusListener();
 #endif  // defined(OS_ANDROID)
 
 #if !defined(DISABLE_NACL)
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(nacl::NaClProcessHost::EarlyStartup));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(nacl::NaClProcessHost::EarlyStartup));

[manzagop (departed), 2016/08/18 15:59:56]

Yes, this is too big a diff. I really think git cl format only is supposed to
edit changed lines, but it may be the line endings switcharoos we suffered. If
it's easy enough, I'd check out the master version of the file and manually
reapply your changes before sending to the next reviewer.

[gcomanici, 2016/08/19 16:04:31]

Done.

 #endif  // !defined(DISABLE_NACL)
 
   // Make sure initial prefs are recorded
   PrefMetricsService::Factory::GetForProfile(profile_);
 
   PreBrowserStart();
 
   // Instantiate the notification UI manager, as this triggers a perf timer
   // used to measure startup time. TODO(stevenjb): Figure out what is actually
   // triggering the timer and call that explicitly in the approprate place.
@@ skipping 258 matching lines @@
   chromeos::CrosSettings::Shutdown();
 #endif  // defined(OS_CHROMEOS)
 #endif  // defined(OS_ANDROID)
 }
 
 // Public members:
 
 void ChromeBrowserMainParts::AddParts(ChromeBrowserMainExtraParts* parts) {
   chrome_extra_parts_.push_back(parts);
 }