Issue 501916 : Add data type counts to 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 "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/history/history_service_factory.h"
+#include "chrome/browser/password_manager/password_store_factory.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 {
+
+class ProfileStatisticsAggregator
+    : public base::RefCountedThreadSafe<ProfileStatisticsAggregator> {
+  // This class collects statistical information about the profile and returns
+  // the information via a callback function. Currently bookmarks, history,
+  // logins and preferences are counted.
+  //
+  // The class is RefCounted because this is needed for CancelableTaskTracker
+  // to function properly. Once all tasks are run (or cancelled) the instance is
+  // automatically destructed.
+  //
+  // The class is used internally by GetProfileStatistics function.
+
+ public:
+  // Constructor
+  explicit ProfileStatisticsAggregator(Profile* profile,
+      const profiles::ProfileStatisticsCallback& callback,
+      base::CancelableTaskTracker* tracker);
+
+ private:
+  // Destructor
+  friend class base::RefCountedThreadSafe<ProfileStatisticsAggregator>;
+  ~ProfileStatisticsAggregator() {}
+
+  Profile* profile_;
+  profiles::ProfileStatisticsValues profile_stats_values_;
+
+  // Callback function to be called when results arrive. Will be called
+  // multiple times (once for each statistics).
+  const profiles::ProfileStatisticsCallback callback_;
+
+  base::CancelableTaskTracker* tracker_;
+
+  // Initialization. Called by constructors.
+  void Init();
+
+  // Internal callback. Appends result to profile_stats_values_, and then
+  // call the external callback.
+  void StatisticsCallback(std::string category, int count);
+
+  // Bookmark counting.
+  static int CountBookmarksFromNode(const bookmarks::BookmarkNode* node);
+  int CountBookmarks() const;
+
+  // Preference counting.
+  int CountPrefs() const;
+
+  // Password counting
+  class PasswordStoreConsumerHelper
+      : public password_manager::PasswordStoreConsumer {
+   public:
+    explicit PasswordStoreConsumerHelper(ProfileStatisticsAggregator* parent)
+        : parent_(parent) {}
+
+    void OnGetPasswordStoreResults(
+        ScopedVector<autofill::PasswordForm> results) override {
+      parent_->StatisticsCallback(profiles::kProfileStatisticsPasswords,
+          results.size());
+    }
+
+   private:
+    ProfileStatisticsAggregator* parent_;
+
+    DISALLOW_COPY_AND_ASSIGN(PasswordStoreConsumerHelper);
+  };
+  PasswordStoreConsumerHelper password_store_consumer_helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProfileStatisticsAggregator);
+};
+
+ProfileStatisticsAggregator::ProfileStatisticsAggregator(
+    Profile* profile,
+    const profiles::ProfileStatisticsCallback& callback,
+    base::CancelableTaskTracker* tracker)
+    : profile_(profile),
+      callback_(callback),
+      tracker_(tracker),
+      password_store_consumer_helper_(this) {
+  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,
+                     this, profiles::kProfileStatisticsBookmarks));
+
+  // Initiate history counting (async).
+  history::HistoryService* history_service =
+      HistoryServiceFactory::GetForProfileWithoutCreating(profile_);
+
+  if (history_service) {
+    history_service->CountURLs(
+        base::Bind(&ProfileStatisticsAggregator::StatisticsCallback,
+                   this, profiles::kProfileStatisticsBrowsingHistory),
+        tracker_);
+  } else {
+    StatisticsCallback(profiles::kProfileStatisticsBrowsingHistory, 0);
+  }
+
+  // Initiate stored password counting (async).
+  // TODO(anthonyvd): make password task cancellable.
+  scoped_refptr<password_manager::PasswordStore> password_store =
+      PasswordStoreFactory::GetForProfile(
+          profile_, ServiceAccessType::EXPLICIT_ACCESS);
+  if (password_store) {
+    password_store->GetAutofillableLogins(&password_store_consumer_helper_);
+  } else {
+    StatisticsCallback(profiles::kProfileStatisticsPasswords, 0);
+  }
+
+  // Initiate preference counting (async). Post to UI thread.
+  tracker_->PostTaskAndReplyWithResult(
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI).get(),
+          FROM_HERE,
+          base::Bind(&ProfileStatisticsAggregator::CountPrefs, this),
+          base::Bind(&ProfileStatisticsAggregator::StatisticsCallback,
+                     this, profiles::kProfileStatisticsSettings));
+}
+
+void ProfileStatisticsAggregator::StatisticsCallback(std::string category,
+                                                     int count) {
+  profile_stats_values_.push_back(std::make_pair(category, count));
+  callback_.Run(profile_stats_values_);
+}
+
+int ProfileStatisticsAggregator::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;
+}
+
+int ProfileStatisticsAggregator::CountBookmarks() const {
+  bookmarks::BookmarkModel* bookmark_model =
+      BookmarkModelFactory::GetForProfileIfExists(profile_);
+
+  if (bookmark_model) {
+    return CountBookmarksFromNode(bookmark_model->bookmark_bar_node()) +
+           CountBookmarksFromNode(bookmark_model->other_node()) +
+           CountBookmarksFromNode(bookmark_model->mobile_node());
+  }
+  return 0;
+}
+
+int ProfileStatisticsAggregator::CountPrefs() const {
+  const PrefService* pref_service = profile_->GetPrefs();
+
+  if (!pref_service)
+    return 0;
+
+  scoped_ptr<base::DictionaryValue> prefs =
+      pref_service->GetPreferenceValuesWithoutPathExpansion();
+
+  int count = 0;
+  for (base::DictionaryValue::Iterator it(*(prefs.get()));
+       !it.IsAtEnd(); it.Advance()) {
+    const PrefService::Preference* pref = pref_service->
+                                              FindPreference(it.key());
+    // Skip all dictionaries (which must be empty by the function call above).
+    if (it.value().GetType() != base::Value::TYPE_DICTIONARY &&
+      pref && pref->IsUserControlled() && !pref->IsDefaultValue()) {
+      ++count;
+    }
+  }
+  return count;
+}
+
+}  // namespace
+
+namespace profiles {
+
+// Constants for the categories in ProfileStatisticsValues
+const char kProfileStatisticsBrowsingHistory[] = "BrowsingHistory";
+const char kProfileStatisticsPasswords[] = "Passwords";
+const char kProfileStatisticsBookmarks[] = "Bookmarks";
+const char kProfileStatisticsSettings[] = "Settings";
+
+void GetProfileStatistics(Profile* profile,
+    const ProfileStatisticsCallback& callback,
+    base::CancelableTaskTracker* tracker) {
+  scoped_refptr<ProfileStatisticsAggregator> aggregator =

[Mike Lerman, 2015/08/13 14:56:33]

This means, I think, that the reference will be deleted as soon as the
constructor finishes executing, even though there are pending tasks. I don't see
anywhere that the tracker holds a scoped_refptr reference to the
ProfileStatisticsAggregator object.

I feel like you need to either have a singleton type reference to a
ProfileStatisticsAggregator (otherwise, each time you attempt to delete a
Profile you'll allocate an object and never release it, although this may be
hard if I call this on multiple Profiles in rapid succession), or you need to
count calls to StatisticsCallback and delete it after the 4th call, or get the
calling UserManagerScreenHandler involved in tracking the objects.

[lwchkg, 2015/08/13 16:20:17]

Correct me if I'm wrong here. As in /src/base/callback.h, the Chromium version
of callback supports refcounting, and it is different from Google callback.

The callback closure will do the refcounting by itself, i.e. "this" in
base::Bind(..., this, ...) creates a scoped_refptr<PSA> that adds to the count.
By now there are six such closures created, so it should be counted six times.

These closures are repackaged by CancelableTaskTracker (see
/src/base/task/cancelable_task_tracker.cc line 100), passed by references
several times, finally stored in a PostTaskAndReplyRelay in line 78 of
/src/base/threading/post_task_and_reply_impl.cc. That relay will be deleted
either in post_task_and_reply_impl.cc line 82 (failure) or line 61 (success),
and the refcount will be released by the deletion. That's why when all the
PostTask finish all the task ProfileStatisticsAggregator gets deleted
automatically.

Anyway, if a refcounted class is never counted, then it is unable to delete
itself. So I've add the temporary scoped_refptr to force the class to be
refcounted at least once. Not sure if the smart compilers will defeat my effort
here.

BTW, I have some concern about possible dangling reference in the code, in
particular, Profile* and BookmarkModel* may be deleted before or during its use.
Is there any way to make sure that the underlying object is alive?

[Mike Lerman, 2015/08/17 14:23:37]

It is assumed that the Profile* is never deleted. BookmarkModel* will, I think,
consequently never be deleted.

[lwchkg, 2015/08/19 06:19:45]

Got it. Thanks!

+      new ProfileStatisticsAggregator(profile, callback, tracker);
+}
+
+}  // namespace profiles