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 {
+
+struct ProfileStatisticsValue {
+  int count;
+  bool success; // false means the statistics failed to load
+};
+
+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::ProfileStatisticsReturn 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();
+
+  // Callback functions
+  // Normal callback

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

period at the end.

+  void StatisticsCallback(std::string category, ProfileStatisticsValue result);

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

If you're going to call the other method "StatisticsCallbackFailure" this should
be called "StatisticsCallbackSuccess". Also, if you call it $Success, then you
can change the 2nd parameter from a ProfileStatisticsValue to an int, and make
the callers of this method simpler.

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

Good idea. This will be used in the password code. BTW I'll still keep the
original two parameter function because there is no way for
PostTaskAndReplyWithResult to choose the correct callback function (i.e.
success/failure).

+  // Callback for reporting failure.
+  void StatisticsCallbackFailure(std::string category);
+  // For history callbacks.
+  void StatisticsCallbackHistory(history::HistoryCountResult result);
+
+  // Implementation of the callbacks. Appends result to profile_stats_values_,
+  // and then call the external callback.
+  void StatisticsCallbackImpl(

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

I'm not a fan of the suffix Impl, it seems odd given the other methods are the
same visibility in the same class. Once StatisticsCallback is called
StatisticsCallbackSuccess, this can perhaps just be called StatisticsCallback?

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

We still need to have a generic method to handle both success and failure, as
PostTaskAndReplyWithResult cannot choose the function to run. BTW, any other
suffix to suggest?

[Mike Lerman, 2015/08/20 14:52:11]

If this were a class I'd go with StatisticsCallbackBase. Sure - go with Impl.

[lwchkg, 2015/08/20 16:06:24]

Base sounds good.

BTW, I've got a new idea. We can change the argument type from <std::string>
into <const char *>, since the arguments passed are constants in <const char
[]>. In this way we don't need a ...Base function to handle reference passing.

[Mike Lerman, 2015/08/20 16:14:28]

sure, sgtm.

+      const std::string& category, const ProfileStatisticsValue& result);
+
+  // Bookmark counting.
+  static int CountBookmarksFromNode(const bookmarks::BookmarkNode* node);
+  ProfileStatisticsValue CountBookmarks() const;
+
+  // Preference counting.
+  ProfileStatisticsValue CountPrefs() const;
+
+  // Password counting
+  class PasswordStoreConsumerHelper
+      : public password_manager::PasswordStoreConsumer {
+   public:
+    explicit PasswordStoreConsumerHelper(ProfileStatisticsAggregator* parent)
+        : parent_(parent) {}
+
+    void OnGetPasswordStoreResults(
+        ScopedVector<autofill::PasswordForm> results) override {
+      ProfileStatisticsValue result;
+      result.count = results.size();
+      result.success = true;
+      parent_->StatisticsCallback(profiles::kProfileStatisticsPasswords,
+                                  result);
+    }
+
+   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->GetHistoryCount(
+        base::Bind(&ProfileStatisticsAggregator::StatisticsCallbackHistory,
+                   this),
+        tracker_);
+  } else {
+    StatisticsCallbackFailure(profiles::kProfileStatisticsBrowsingHistory);
+  }
+
+  // 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 {
+    StatisticsCallbackFailure(profiles::kProfileStatisticsPasswords);
+  }
+
+  // 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, ProfileStatisticsValue result) {
+  StatisticsCallbackImpl(category, result);
+}
+
+void ProfileStatisticsAggregator::StatisticsCallbackFailure(
+    std::string category) {
+  ProfileStatisticsValue result;
+  result.count = 0;
+  result.success = false;
+  StatisticsCallbackImpl(category, result);
+}
+
+void ProfileStatisticsAggregator::StatisticsCallbackHistory(
+    history::HistoryCountResult result) {
+  ProfileStatisticsValue result_converted;
+  result_converted.count = result.count;
+  result_converted.success = result.success;
+  StatisticsCallbackImpl(profiles::kProfileStatisticsBrowsingHistory,
+                         result_converted);
+}
+
+void ProfileStatisticsAggregator::StatisticsCallbackImpl(
+    const std::string& category,
+    const ProfileStatisticsValue& result) {
+  profiles::ProfileStatisticsDatum datum;
+  datum.category = category;
+  datum.count = result.count;
+  datum.success = result.success;
+  profile_stats_values_.push_back(datum);
+  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;
+}
+
+ProfileStatisticsValue ProfileStatisticsAggregator::CountBookmarks() const {
+  bookmarks::BookmarkModel* bookmark_model =
+      BookmarkModelFactory::GetForProfileIfExists(profile_);
+
+  ProfileStatisticsValue result;
+  if (bookmark_model) {
+    result.count = CountBookmarksFromNode(bookmark_model->bookmark_bar_node()) +
+                   CountBookmarksFromNode(bookmark_model->other_node()) +
+                   CountBookmarksFromNode(bookmark_model->mobile_node());
+    result.success = true;
+  } else {
+    result.count = 0;
+    result.success = false;
+  }
+  return result;
+}
+
+ProfileStatisticsValue ProfileStatisticsAggregator::CountPrefs() const {
+  const PrefService* pref_service = profile_->GetPrefs();
+
+  ProfileStatisticsValue result;
+  if (pref_service) {
+    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;
+      }
+    }
+
+    result.count = count;
+    result.success = true;
+  } else {
+    result.count = 0;
+    result.success = false;
+  }
+  return result;
+}
+
+}  // namespace
+
+namespace profiles {
+
+// Constants for the categories in ProfileStatisticsReturn
+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 =
+      new ProfileStatisticsAggregator(profile, callback, tracker);
+}
+
+}  // namespace profiles