Utilize ProfileInfoCache to support data type counts in profile deletion flow

chrome/browser/profiles/profile_statistics.cc

 // Copyright 2015 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_statistics.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/prefs/pref_service.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
+#include "chrome/browser/profiles/profile_attributes_entry.h"
+#include "chrome/browser/profiles/profile_attributes_storage.h"
+#include "chrome/browser/profiles/profile_info_cache.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/password_manager/core/browser/password_store_consumer.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 struct ProfileStatValue {
   int count;
   bool success; // false means the statistics failed to load
 };
 
+void NoOp(profiles::ProfileCategoryStats result) {}
+
 int CountBookmarksFromNode(const bookmarks::BookmarkNode* node) {
   int count = 0;
   if (node->is_url()) {
     ++count;
   } else {
     for (int i = 0; i < node->child_count(); ++i)
       count += CountBookmarksFromNode(node->GetChild(i));
   }
   return count;
 }
@@ skipping 39 matching lines @@
   ProfileStatValue CountPrefs() const;
 
   Profile* profile_;
   profiles::ProfileCategoryStats profile_category_stats_;
 
   // Callback function to be called when results arrive. Will be called
   // multiple times (once for each statistics).
   const profiles::ProfileStatisticsCallback callback_;
 
   base::CancelableTaskTracker* tracker_;
+  scoped_ptr<base::CancelableTaskTracker> default_tracker_;
 
   // Password counting.
   class PasswordStoreConsumerHelper
       : public password_manager::PasswordStoreConsumer {
    public:
     explicit PasswordStoreConsumerHelper(ProfileStatisticsAggregator* parent)
         : parent_(parent) {}
 
     void OnGetPasswordStoreResults(
         ScopedVector<autofill::PasswordForm> results) override {
@@ skipping 12 matching lines @@
 };
 
 ProfileStatisticsAggregator::ProfileStatisticsAggregator(
     Profile* profile,
     const profiles::ProfileStatisticsCallback& callback,
     base::CancelableTaskTracker* tracker)
     : profile_(profile),
       callback_(callback),
       tracker_(tracker),
       password_store_consumer_helper_(this) {
+  if (!tracker_) {
+    default_tracker_.reset(new base::CancelableTaskTracker);
+    tracker_ = default_tracker_.get();
+  }
   Init();
 }
 
 void ProfileStatisticsAggregator::Init() {
   // Initiate bookmark counting (async). Post to UI thread.
   tracker_->PostTaskAndReplyWithResult(
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI).get(),
           FROM_HERE,
           base::Bind(&ProfileStatisticsAggregator::CountBookmarks, this),
           base::Bind(&ProfileStatisticsAggregator::StatisticsCallback,
@@ skipping 35 matching lines @@
 }
 
 void ProfileStatisticsAggregator::StatisticsCallback(
     const char* category, ProfileStatValue result) {
   profiles::ProfileCategoryStat datum;
   datum.category = category;
   datum.count = result.count;
   datum.success = result.success;
   profile_category_stats_.push_back(datum);
   callback_.Run(profile_category_stats_);
+
+  // Set statistic in ProfileInfoCache if possible.
+  // Note: if local_state() is null, profile_manager() will seg-fault.
+  if (result.success && g_browser_process && g_browser_process->local_state()) {
+    ProfileInfoCache& profile_info_cache =

[Mike Lerman, 2015/11/03 20:50:42]

const ProfileInfoCache& please

[lwchkg, 2015/11/04 00:11:07]

Acknowledged.

[lwchkg, 2015/11/05 22:21:30]

I've tried, but the compiler complains.

e:\chromium\src\chrome\browser\profiles\profile_statistics.cc(197) : error
C2662: 'bool ProfileInfoCache::GetProfileAttributesWithPath(const base::FilePath
&,ProfileAttributesEntry **)' : cannot convert 'this' pointer from 'const
ProfileInfoCache' to 'ProfileInfoCache &'
        Conversion loses qualifiers

Anyway, found that reference types cannot be CV-qualified. See
http://en.cppreference.com/w/cpp/language/reference

[Mike Lerman, 2015/11/10 15:45:44]

Ah - getProfileAttributesWithPath isn't const. Sorry my bad.

+        g_browser_process->profile_manager()->GetProfileInfoCache();
+    if (&profile_info_cache) {

[Mike Lerman, 2015/11/03 20:50:42]

you can assume if you have a ProfileManager than you have a ProfileInfoCache. It
is returning an object ref, not a pointer, after all.

[lwchkg, 2015/11/04 00:11:07]

You're right. Thanks.

+      ProfileAttributesEntry* entry = nullptr;
+      if (profile_info_cache.GetProfileAttributesWithPath(
+          profile_->GetPath(), &entry)) {
+        entry->SetStatistic(datum.category, result.count);
+      }
+    }
+  }
 }
 
 void ProfileStatisticsAggregator::StatisticsCallbackSuccess(
     const char* category, int count) {
   ProfileStatValue result;
   result.count = count;
   result.success = true;
   StatisticsCallback(category, result);
 }
 
@@ skipping 70 matching lines @@
 const char kProfileStatisticsBookmarks[] = "Bookmarks";
 const char kProfileStatisticsSettings[] = "Settings";
 
 void GetProfileStatistics(Profile* profile,
     const ProfileStatisticsCallback& callback,
     base::CancelableTaskTracker* tracker) {
   scoped_refptr<ProfileStatisticsAggregator> aggregator =
       new ProfileStatisticsAggregator(profile, callback, tracker);
 }
 
+void StoreProfileStatisticsToCache(Profile* profile) {
+  GetProfileStatistics(profile, base::Bind(&NoOp), nullptr);

[Mike Lerman, 2015/11/03 20:50:42]

I think you can just write profiles::ProfileCatgeoryStats() as the second bound
parameter; you don't need to explicitly define NoOp.

[lwchkg, 2015/11/04 00:11:07]

Not sure about this. Will try tonight.

[lwchkg, 2015/11/05 22:21:30]

Tried but not succeeded. I've tried to make a lambda function, but it is no good
because lambdas are prvalue which cannot be bound.

Anyway I hate that explicit NoOp. Any ideas?

[Mike Lerman, 2015/11/10 15:45:44]

Aha! Found an example:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/pro...

We call profiles::SwitchToProfile() in a bunch of places, but for the 4th
parameter we often provide a Noop() callback. There's example syntax for you.

[lwchkg, 2015/11/10 18:11:07]

Thanks. It's working well!

+}
+
 }  // namespace profiles