Offer user to send feedback from profile error dialog

chrome/browser/prefs/chrome_pref_service_factory.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/prefs/chrome_pref_service_factory.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 335 matching lines @@
       data.enforcement_level = PrefHashFilter::ENFORCE_ON_LOAD;
     }
 #endif
 
     result.push_back(data);
   }
   return result;
 }
 
 // Shows notifications which correspond to PersistentPrefStore's reading errors.
-void HandleReadError(PersistentPrefStore::PrefReadError error) {
+void HandleReadError(const base::FilePath& pref_filename,
+                     PersistentPrefStore::PrefReadError error) {
   // Sample the histogram also for the successful case in order to get a
   // baseline on the success rate in addition to the error distribution.
   UMA_HISTOGRAM_ENUMERATION("PrefService.ReadError", error,
                             PersistentPrefStore::PREF_READ_ERROR_MAX_ENUM);
 
   if (error != PersistentPrefStore::PREF_READ_ERROR_NONE) {
 #if !defined(OS_CHROMEOS)
     // Failing to load prefs on startup is a bad thing(TM). See bug 38352 for
     // an example problem that this can cause.
     // Do some diagnosis and try to avoid losing data.
     int message_id = 0;
     if (error <= PersistentPrefStore::PREF_READ_ERROR_JSON_TYPE) {
       message_id = IDS_PREFERENCES_CORRUPT_ERROR;
     } else if (error != PersistentPrefStore::PREF_READ_ERROR_NO_FILE) {
       message_id = IDS_PREFERENCES_UNREADABLE_ERROR;
     }
 
     if (message_id) {
-      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                              base::Bind(&ShowProfileErrorDialog,
-                                         PROFILE_ERROR_PREFERENCES,
-                                         message_id));
+      std::string diagnostics("Corrupted file: ");
+      diagnostics += pref_filename.DirName().BaseName().AsUTF8Unsafe() + "/" +

[Lei Zhang, 2016/07/16 00:35:21]

Do you care that on Windows, this will be foo/bar, rather than foo\bar?

[afakhry, 2016/07/18 17:43:51]

No, it doesn't matter. All we need to know is the file name and whether it's a
user or a default profile.

+                     pref_filename.BaseName().AsUTF8Unsafe() + "\n";
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&ShowProfileErrorDialog, PROFILE_ERROR_PREFERENCES,
+                     message_id, diagnostics));
     }
 #else
     // On ChromeOS error screen with message about broken local state
     // will be displayed.
 
     // A supplementary error message about broken local state - is included
     // in logs and user feedbacks.
     if (error != PersistentPrefStore::PREF_READ_ERROR_NONE &&
         error != PersistentPrefStore::PREF_READ_ERROR_NO_FILE) {
       LOG(ERROR) << "An error happened during prefs loading: " << error;
@@ skipping 17 matching lines @@
   std::string seed;
 #if defined(GOOGLE_CHROME_BUILD)
   seed = ResourceBundle::GetSharedInstance().GetRawDataResource(
       IDR_PREF_HASH_SEED_BIN).as_string();
 #endif
   return base::WrapUnique(new ProfilePrefStoreManager(
       profile_path, GetTrackingConfiguration(), kTrackedPrefsReportingIDsCount,
       seed, device_id, g_browser_process->local_state()));
 }
 
-void PrepareFactory(
-    syncable_prefs::PrefServiceSyncableFactory* factory,
-    policy::PolicyService* policy_service,
-    SupervisedUserSettingsService* supervised_user_settings,
-    scoped_refptr<PersistentPrefStore> user_pref_store,
-    const scoped_refptr<PrefStore>& extension_prefs,
-    bool async) {
+void PrepareFactory(const base::FilePath& pref_filename,

[Lei Zhang, 2016/07/16 00:35:21]

Why is this the first param? Shouldn't it be |factory|, the thing that we are
preparing?

[afakhry, 2016/07/18 17:43:51]

Done.

+                    syncable_prefs::PrefServiceSyncableFactory* factory,
+                    policy::PolicyService* policy_service,
+                    SupervisedUserSettingsService* supervised_user_settings,
+                    scoped_refptr<PersistentPrefStore> user_pref_store,
+                    const scoped_refptr<PrefStore>& extension_prefs,
+                    bool async) {
   policy::BrowserPolicyConnector* policy_connector =
       g_browser_process->browser_policy_connector();
   factory->SetManagedPolicies(policy_service, policy_connector);
   factory->SetRecommendedPolicies(policy_service, policy_connector);
 
 #if defined(ENABLE_SUPERVISED_USERS)
   if (supervised_user_settings) {
     scoped_refptr<PrefStore> supervised_user_prefs = make_scoped_refptr(
         new SupervisedUserPrefStore(supervised_user_settings));
     DCHECK(async || supervised_user_prefs->IsInitializationComplete());
     factory->set_supervised_user_prefs(supervised_user_prefs);
   }
 #endif
 
   factory->set_async(async);
   factory->set_extension_prefs(extension_prefs);
   factory->set_command_line_prefs(make_scoped_refptr(
       new CommandLinePrefStore(base::CommandLine::ForCurrentProcess())));
-  factory->set_read_error_callback(base::Bind(&HandleReadError));
+  factory->set_read_error_callback(base::Bind(&HandleReadError, pref_filename));
   factory->set_user_prefs(user_pref_store);
   factory->SetPrefModelAssociatorClient(
       ChromePrefModelAssociatorClient::GetInstance());
 }
 
 }  // namespace
 
 namespace chrome_prefs {
 
 namespace internals {
@@ skipping 10 matching lines @@
 
 }  // namespace internals
 
 std::unique_ptr<PrefService> CreateLocalState(
     const base::FilePath& pref_filename,
     base::SequencedTaskRunner* pref_io_task_runner,
     policy::PolicyService* policy_service,
     const scoped_refptr<PrefRegistry>& pref_registry,
     bool async) {
   syncable_prefs::PrefServiceSyncableFactory factory;
-  PrepareFactory(&factory, policy_service,
+  PrepareFactory(pref_filename, &factory, policy_service,
                  NULL,  // supervised_user_settings
                  new JsonPrefStore(pref_filename, pref_io_task_runner,
                                    std::unique_ptr<PrefFilter>()),
                  NULL,  // extension_prefs
                  async);
   return factory.Create(pref_registry.get());
 }
 
 std::unique_ptr<syncable_prefs::PrefServiceSyncable> CreateProfilePrefs(
     const base::FilePath& profile_path,
@@ skipping 16 matching lines @@
   const base::Closure start_sync_flare_for_prefs =
       base::Bind(sync_start_util::GetFlareForSyncableService(profile_path),
                  syncer::PREFERENCES);
 
   syncable_prefs::PrefServiceSyncableFactory factory;
   scoped_refptr<PersistentPrefStore> user_pref_store(
       CreateProfilePrefStoreManager(profile_path)
           ->CreateProfilePrefStore(pref_io_task_runner,
                                    start_sync_flare_for_prefs,
                                    validation_delegate));
-  PrepareFactory(&factory,
-                 policy_service,
-                 supervised_user_settings,
-                 user_pref_store,
-                 extension_prefs,
+  PrepareFactory(profile_path, &factory, policy_service,
+                 supervised_user_settings, user_pref_store, extension_prefs,
                  async);
   std::unique_ptr<syncable_prefs::PrefServiceSyncable> pref_service =
       factory.CreateSyncable(pref_registry.get());
 
   ConfigureDefaultSearchPrefMigrationToDictionaryValue(pref_service.get());
 
   return pref_service;
 }
 
 void DisableDomainCheckForTesting() {
@@ skipping 19 matching lines @@
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   ProfilePrefStoreManager::RegisterPrefs(registry);
 }
 
 }  // namespace chrome_prefs