Count site data size for important sites

chrome/browser/engagement/important_sites_util.cc

 // Copyright 2016 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/engagement/important_sites_util.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
@@ skipping 14 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/WebKit/public/platform/site_engagement.mojom.h"
 #include "url/gurl.h"
+#include "url/url_util.h"
 
 namespace {
 using bookmarks::BookmarkModel;
 using ImportantDomainInfo = ImportantSitesUtil::ImportantDomainInfo;
 using ImportantReason = ImportantSitesUtil::ImportantReason;
 
 // Note: These values are stored on both the per-site content settings
 // dictionary and the dialog preference dictionary.
 
 static const char kTimeLastIgnored[] = "TimeLastIgnored";
@@ skipping 80 matching lines @@
     return CROSSED_DURABLE_AND_ENGAGEMENT;
   else if (notifications)
     return CROSSED_NOTIFICATIONS;
   else if (durable)
     return CROSSED_DURABLE;
   else if (engagement)
     return CROSSED_ENGAGEMENT;
   return CROSSED_REASON_UNKNOWN;
 }
 
-std::string GetRegisterableDomainOrIP(const GURL& url) {
-  std::string registerable_domain =
-      net::registry_controlled_domains::GetDomainAndRegistry(
-          url, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
-  if (registerable_domain.empty() && url.HostIsIPAddress())
-    registerable_domain = url.host();
-  return registerable_domain;
-}
-
 void MaybePopulateImportantInfoForReason(
     const GURL& origin,
     std::set<GURL>* visited_origins,
     ImportantReason reason,
     base::hash_map<std::string, ImportantDomainInfo>* output) {
   if (!origin.is_valid() || !visited_origins->insert(origin).second)
     return;
-  std::string registerable_domain = GetRegisterableDomainOrIP(origin);
+  std::string registerable_domain =
+      ImportantSitesUtil::GetRegisterableDomainOrIP(origin);
   ImportantDomainInfo& info = (*output)[registerable_domain];
   info.reason_bitfield |= 1 << reason;
   if (info.example_origin.is_empty()) {
     info.registerable_domain = registerable_domain;
     info.example_origin = origin;
   }
 }
 
 // Returns the score associated with the given reason. The order of
 // ImportantReason does not need to correspond to the score order. The higher
@@ skipping 76 matching lines @@
   SiteEngagementService* service = SiteEngagementService::Get(profile);
   *engagement_map = service->GetScoreMap();
   // We can have multiple origins for a single domain, so we record the one
   // with the highest engagement score.
   for (const auto& url_engagement_pair : *engagement_map) {
     if (!service->IsEngagementAtLeast(url_engagement_pair.first,
                                       minimum_engagement)) {
       continue;
     }
     std::string registerable_domain =
-        GetRegisterableDomainOrIP(url_engagement_pair.first);
+        ImportantSitesUtil::GetRegisterableDomainOrIP(
+            url_engagement_pair.first);
     ImportantDomainInfo& info = (*output)[registerable_domain];
     if (url_engagement_pair.second > info.engagement_score) {
       info.registerable_domain = registerable_domain;
       info.engagement_score = url_engagement_pair.second;
       info.example_origin = url_engagement_pair.first;
       info.reason_bitfield |= 1 << ImportantReason::ENGAGEMENT;
     }
   }
 }
 
@@ skipping 81 matching lines @@
     GURL origin(site.primary_pattern.ToString());
     if (!AppBannerSettingsHelper::WasLaunchedRecently(profile, origin, now))
       continue;
     MaybePopulateImportantInfoForReason(origin, &content_origins,
                                         ImportantReason::HOME_SCREEN, output);
   }
 }
 
 }  // namespace
 
+std::string ImportantSitesUtil::GetRegisterableDomainOrIP(const GURL& url) {
+  return GetRegisterableDomainOrIPFromHost(url.host_piece());
+}
+
+std::string ImportantSitesUtil::GetRegisterableDomainOrIPFromHost(
+    base::StringPiece host) {
+  std::string registerable_domain =
+      net::registry_controlled_domains::GetDomainAndRegistry(
+          host, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+  if (registerable_domain.empty() && url::HostIsIPAddress(host))
+    registerable_domain = std::string(host);

[Bernhard Bauer, 2017/05/04 14:16:45]

I would just directly return std::string(host).

[dullweber, 2017/05/05 08:35:28]

Done.

+  return registerable_domain;
+}
+
 bool ImportantSitesUtil::IsDialogDisabled(Profile* profile) {
   PrefService* service = profile->GetPrefs();
   DictionaryPrefUpdate update(service, prefs::kImportantSitesDialogHistory);
 
   return ShouldSuppressItem(update.Get());
 }
 
 void ImportantSitesUtil::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(prefs::kImportantSitesDialogHistory);
@@ skipping 118 matching lines @@
                                                          const GURL& origin) {
   SiteEngagementScore::SetParamValuesForTesting();
   // First get data from site engagement.
   SiteEngagementService* site_engagement_service =
       SiteEngagementService::Get(profile);
   site_engagement_service->ResetBaseScoreForURL(
       origin, SiteEngagementScore::GetMediumEngagementBoundary());
   DCHECK(site_engagement_service->IsEngagementAtLeast(
       origin, blink::mojom::EngagementLevel::MEDIUM));
 }