Utilize ProfileInfoCache to support data type counts in profile deletion flow

chrome/browser/ui/webui/signin/user_manager_screen_handler.cc

 // Copyright 2013 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/ui/webui/signin/user_manager_screen_handler.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/screenlock_private/screenlock_private_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_info_cache_observer.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
+#include "chrome/browser/profiles/profile_statistics.h"
 #include "chrome/browser/profiles/profile_window.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/signin/local_auth.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/chrome_pages.h"
@@ skipping 30 matching lines @@
 const char kKeyProfilePath[] = "profilePath";
 const char kKeyPublicAccount[] = "publicAccount";
 const char kKeyLegacySupervisedUser[] = "legacySupervisedUser";
 const char kKeyChildUser[] = "childUser";
 const char kKeyCanRemove[] = "canRemove";
 const char kKeyIsOwner[] = "isOwner";
 const char kKeyIsDesktop[] = "isDesktopUser";
 const char kKeyAvatarUrl[] = "userImage";
 const char kKeyNeedsSignin[] = "needsSignin";
 const char kKeyHasLocalCreds[] = "hasLocalCreds";
+const char kKeyStatistics[] = "statistics";
 const char kKeyIsProfileLoaded[] = "isProfileLoaded";
 
 // JS API callback names.
 const char kJsApiUserManagerInitialize[] = "userManagerInitialize";
 const char kJsApiUserManagerAddUser[] = "addUser";
 const char kJsApiUserManagerAuthLaunchUser[] = "authenticatedLaunchUser";
 const char kJsApiUserManagerLaunchGuest[] = "launchGuest";
 const char kJsApiUserManagerLaunchUser[] = "launchUser";
 const char kJsApiUserManagerRemoveUser[] = "removeUser";
 const char kJsApiUserManagerAttemptUnlock[] = "attemptUnlock";
@@ skipping 490 matching lines @@
   if (!base::GetValueAsFilePath(*profile_path_value, &profile_path))
     return;
 
   base::StringValue return_profile_path(profile_path.value());
   Profile* profile = g_browser_process->profile_manager()->
       GetProfileByPath(profile_path);
 
   if (!profile)
     return;
 
-  profiles::GetProfileStatistics(
+  if (!chrome::FindAnyBrowser(profile, true, desktop_type_)) {
+    // If no windows are open for that profile, the statistics in
+    // ProfileInfoCache are up to date. The statistics in ProfileInfoCache are
+    // returned because the copy in user_pod_row.js may be outdated. However, if
+    // some statistics are missing in ProfileInfoCache (i.e. |item.success| is
+    // false), then the actual statistics are queried instead.
+    base::DictionaryValue return_value;
+    profiles::ProfileCategoryStats stats =
+        profiles::GetProfileStatisticsFromCache(profile_path);
+    bool stats_success = true;
+    for (const auto& item : stats) {
+      scoped_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
+      stat->SetIntegerWithoutPathExpansion("count", item.count);
+      stat->SetBooleanWithoutPathExpansion("success", item.success);
+      return_value.SetWithoutPathExpansion(item.category, std::move(stat));
+      stats_success &= item.success;
+    }
+    if (stats_success) {
+      web_ui()->CallJavascriptFunction("updateRemoveWarningDialog",
+                                       base::StringValue(profile_path.value()),
+                                       return_value);
+      return;
+    }
+  }
+
+  profiles::GatherProfileStatistics(
       profile,
       base::Bind(
           &UserManagerScreenHandler::RemoveUserDialogLoadStatsCallback,
           weak_ptr_factory_.GetWeakPtr(), profile_path),
       &tracker_);
 }
 
 void UserManagerScreenHandler::RemoveUserDialogLoadStatsCallback(
     base::FilePath profile_path,
     profiles::ProfileCategoryStats result) {
   // Copy result into return_value.
-  base::StringValue return_profile_path(profile_path.value());
   base::DictionaryValue return_value;
   for (const auto& item : result) {
-    base::DictionaryValue* stat = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
     stat->SetIntegerWithoutPathExpansion("count", item.count);
     stat->SetBooleanWithoutPathExpansion("success", item.success);
-    return_value.SetWithoutPathExpansion(item.category, stat);
+    return_value.SetWithoutPathExpansion(item.category, std::move(stat));
   }
   web_ui()->CallJavascriptFunction("updateRemoveWarningDialog",
-                                   return_profile_path, return_value);
+                                   base::StringValue(profile_path.value()),
+                                   return_value);
 }
 
 void UserManagerScreenHandler::HandleGetRemoveWarningDialogMessage(
     const base::ListValue* args) {
   const base::DictionaryValue* arg;
   if (!args->GetDictionary(0, &arg))
     return;
 
   std::string profile_path("");
   bool is_synced_user = false;
@@ skipping 252 matching lines @@
         kKeyNeedsSignin, info_cache->ProfileIsSigninRequiredAtIndex(i));
     profile_value->SetBoolean(
         kKeyHasLocalCreds,
         !info_cache->GetLocalAuthCredentialsOfProfileAtIndex(i).empty());
     profile_value->SetBoolean(kKeyIsOwner, false);
     profile_value->SetBoolean(kKeyCanRemove, can_remove);
     profile_value->SetBoolean(kKeyIsDesktop, true);
     profile_value->SetString(
         kKeyAvatarUrl, GetAvatarImageAtIndex(i, info_cache));
 
+    profiles::ProfileCategoryStats stats =
+        profiles::GetProfileStatisticsFromCache(profile_path);
+    scoped_ptr<base::DictionaryValue> stats_dict(new base::DictionaryValue);
+    for (const auto& item : stats) {
+      scoped_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
+      stat->SetIntegerWithoutPathExpansion("count", item.count);
+      stat->SetBooleanWithoutPathExpansion("success", item.success);
+      stats_dict->SetWithoutPathExpansion(item.category, std::move(stat));
+    }
+    profile_value->SetWithoutPathExpansion(kKeyStatistics,
+                                           std::move(stats_dict));
+
     // GetProfileByPath returns a pointer if the profile is fully loaded, NULL
     // otherwise.
     Profile* profile =
         g_browser_process->profile_manager()->GetProfileByPath(profile_path);
     profile_value->SetBoolean(kKeyIsProfileLoaded, profile != nullptr);
 
     users_list.Append(profile_value);
   }
 
   web_ui()->CallJavascriptFunction("login.AccountPickerScreen.loadUsers",
@@ skipping 83 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false, desktop_type_);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }