RefCounted types should not have public destructors, chrome/ remaining parts

chrome/common/extensions/extension_permission_set.cc

 // Copyright (c) 2012 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/common/extensions/extension_permission_set.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 127 matching lines @@
   }
 
   return ExtensionPermissionMessage(message_id, message);
 }
 
 ExtensionPermissionMessage::ExtensionPermissionMessage(
     ExtensionPermissionMessage::ID id, const string16& message)
   : id_(id), message_(message) {
 }
 
-ExtensionPermissionMessage::~ExtensionPermissionMessage() {
-}
+ExtensionPermissionMessage::~ExtensionPermissionMessage() {}
 
 //
 // ExtensionPermission
 //
 
+ExtensionAPIPermission::~ExtensionAPIPermission() {}
+
 ExtensionPermissionMessage ExtensionAPIPermission::GetMessage() const {
   return ExtensionPermissionMessage(
       message_id_, l10n_util::GetStringUTF16(l10n_message_id_));
 }
 
 ExtensionAPIPermission::ExtensionAPIPermission(
     ID id,
     const char* name,
     int l10n_message_id,
     ExtensionPermissionMessage::ID message_id,
     int flags)
     : id_(id),
       name_(name),
       flags_(flags),
       l10n_message_id_(l10n_message_id),
       message_id_(message_id) {}
 
-ExtensionAPIPermission::~ExtensionAPIPermission() {}
-
 // static
 void ExtensionAPIPermission::RegisterAllPermissions(
     ExtensionPermissionsInfo* info) {
 
   // Register permissions for all extension types.
   info->RegisterPermission(
       kBackground, "background", 0,
       ExtensionPermissionMessage::kNone, kFlagNone);
   info->RegisterPermission(
       kClipboardRead, "clipboardRead", IDS_EXTENSION_PROMPT_WARNING_CLIPBOARD,
@@ skipping 214 matching lines @@
     delete i->second;
 }
 
 ExtensionPermissionsInfo::ExtensionPermissionsInfo()
     : hosted_app_permission_count_(0),
       permission_count_(0) {
   ExtensionAPIPermission::RegisterAllPermissions(this);
 }
 
 void ExtensionPermissionsInfo::RegisterAlias(
-    const char* name, const char* alias) {
+    const char* name,

[Nico, 2012/04/25 13:20:37]

?

[Ryan Sleevi, 2012/04/25 15:13:59]

Style guide. Only two forms: all on one line or one per line at four spaces.

+    const char* alias) {
   DCHECK(name_map_.find(name) != name_map_.end());
   DCHECK(name_map_.find(alias) == name_map_.end());
   name_map_[alias] = name_map_[name];
 }
 
 ExtensionAPIPermission* ExtensionPermissionsInfo::RegisterPermission(
     ExtensionAPIPermission::ID id,
     const char* name,
     int l10n_message_id,
     ExtensionPermissionMessage::ID message_id,
     int flags) {
   DCHECK(id_map_.find(id) == id_map_.end());
   DCHECK(name_map_.find(name) == name_map_.end());
 
   ExtensionAPIPermission* permission = new ExtensionAPIPermission(
       id, name, l10n_message_id, message_id, flags);
 
   id_map_[id] = permission;
   name_map_[name] = permission;
 
   permission_count_++;
 
   return permission;
 }
 
 //
 // ExtensionPermissionSet
 //
 
-ExtensionPermissionSet::ExtensionPermissionSet() {
-}
+ExtensionPermissionSet::ExtensionPermissionSet() {}
 
 ExtensionPermissionSet::ExtensionPermissionSet(
     const Extension* extension,
     const ExtensionAPIPermissionSet& apis,
     const URLPatternSet& explicit_hosts,
     const ExtensionOAuth2Scopes& scopes)
     : apis_(apis),
       scopes_(scopes) {
   DCHECK(extension);
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
@@ skipping 22 matching lines @@
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitEffectiveHosts();
 }
 
 ExtensionPermissionSet::ExtensionPermissionSet(
     const ExtensionOAuth2Scopes& scopes)
     : scopes_(scopes) {
   InitEffectiveHosts();
 }
 
-ExtensionPermissionSet::~ExtensionPermissionSet() {}

[Nico, 2012/04/25 13:20:37]

Wasn't the consensus on that thread to keep constructors and destructors next to
each other?

[Ryan Sleevi, 2012/04/25 15:13:59]

No, it was "the style guide says X so we do X, no exceptions."

-
 // static
 ExtensionPermissionSet* ExtensionPermissionSet::CreateDifference(
     const ExtensionPermissionSet* set1,
     const ExtensionPermissionSet* set2) {
   scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
   const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
   const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
 
   ExtensionAPIPermissionSet apis;
   std::set_difference(set1_safe->apis().begin(), set1_safe->apis().end(),
@@ skipping 300 matching lines @@
 
   if (HasLessAPIPrivilegesThan(permissions))
     return true;
 
   if (HasLessScopesThan(permissions))
     return true;
 
   return false;
 }
 
+ExtensionPermissionSet::~ExtensionPermissionSet() {}
+
 // static
 std::set<std::string> ExtensionPermissionSet::GetDistinctHosts(
     const URLPatternSet& host_patterns,
     bool include_rcd,
     bool exclude_file_scheme) {
   // Use a vector to preserve order (also faster than a map on small sets).
   // Each item is a host split into two parts: host without RCDs and
   // current best RCD.
   typedef std::vector<std::pair<std::string, std::string> > HostVector;
   HostVector hosts_best_rcd;
@@ skipping 34 matching lines @@
   }
 
   // Build up the final vector by concatenating hosts and RCDs.
   std::set<std::string> distinct_hosts;
   for (HostVector::iterator it = hosts_best_rcd.begin();
        it != hosts_best_rcd.end(); ++it)
     distinct_hosts.insert(it->first + it->second);
   return distinct_hosts;
 }
 
-void ExtensionPermissionSet::InitEffectiveHosts() {
-  effective_hosts_.ClearPatterns();
-
-  URLPatternSet::CreateUnion(
-      explicit_hosts(), scriptable_hosts(), &effective_hosts_);
-}
-
 void ExtensionPermissionSet::InitImplicitExtensionPermissions(
     const Extension* extension) {
   // Add the implied permissions.
   if (!extension->plugins().empty())
     apis_.insert(ExtensionAPIPermission::kPlugin);
 
   if (!extension->devtools_url().is_empty())
     apis_.insert(ExtensionAPIPermission::kDevtools);
 
   // Add the scriptable hosts.
   for (UserScriptList::const_iterator content_script =
            extension->content_scripts().begin();
        content_script != extension->content_scripts().end(); ++content_script) {
     URLPatternSet::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern)
       scriptable_hosts_.AddPattern(*pattern);
   }
 }
 
+void ExtensionPermissionSet::InitEffectiveHosts() {
+  effective_hosts_.ClearPatterns();
+
+  URLPatternSet::CreateUnion(
+      explicit_hosts(), scriptable_hosts(), &effective_hosts_);
+}
+
 std::set<ExtensionPermissionMessage>
     ExtensionPermissionSet::GetSimplePermissionMessages() const {
   std::set<ExtensionPermissionMessage> messages;
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   for (ExtensionAPIPermissionSet::const_iterator i = apis_.begin();
        i != apis_.end(); ++i) {
     DCHECK_GT(ExtensionPermissionMessage::kNone,
               ExtensionPermissionMessage::kUnknown);
     ExtensionAPIPermission* perm = info->GetByID(*i);
     if (perm && perm->message_id() > ExtensionPermissionMessage::kNone)
@@ skipping 56 matching lines @@
   ExtensionOAuth2Scopes current_scopes = scopes();
   ExtensionOAuth2Scopes new_scopes = permissions->scopes();
   ExtensionOAuth2Scopes delta_scopes;
   std::set_difference(new_scopes.begin(), new_scopes.end(),
                       current_scopes.begin(), current_scopes.end(),
                       std::inserter(delta_scopes, delta_scopes.begin()));
 
   // We have less privileges if there are additional scopes present.
   return !delta_scopes.empty();
 }