Extensions: Switch to new permission message system, part I

chrome/common/extensions/permissions/chrome_permission_message_provider.cc

 // Copyright 2013 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/permissions/chrome_permission_message_provider.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/common/extensions/permissions/chrome_permission_message_rules.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/permissions/permission_message.h"
 #include "extensions/common/permissions/permission_message_util.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
 #include "grit/extensions_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
-bool IsNewPermissionMessageSystemEnabled() {
-  const std::string group_name =
-      base::FieldTrialList::FindFullName("PermissionMessageSystem");
-  return group_name == "NewSystem";
-}
-
 typedef std::set<PermissionMessage> PermissionMsgSet;
 
 template<typename T>
 typename T::iterator FindMessageByID(T& messages, int id) {
   for (typename T::iterator it = messages.begin();
        it != messages.end(); ++it) {
     if (it->id() == id)
       return it;
   }
   return messages.end();
@@ skipping 37 matching lines @@
 }
 
 }  // namespace
 
 ChromePermissionMessageProvider::ChromePermissionMessageProvider() {
 }
 
 ChromePermissionMessageProvider::~ChromePermissionMessageProvider() {
 }
 
-PermissionMessages ChromePermissionMessageProvider::GetPermissionMessages(
+PermissionMessages ChromePermissionMessageProvider::GetLegacyPermissionMessages(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
   PermissionMessages messages;
   // TODO(sashab): Check if this the correct logic - if an app has effective
   // full access (i.e. the plugin permission), do we not want to display *any*
   // other permission messages?
   if (permissions->HasEffectiveFullAccess()) {
     messages.push_back(PermissionMessage(
         PermissionMessage::kFullAccess,
         l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_FULL_ACCESS)));
@@ skipping 34 matching lines @@
   kSuppressList.insert(
       {PermissionMessage::kHostsAll, PermissionMessage::kTabs});
   // Tabs already allows reading favicons.
   kSuppressList.insert({PermissionMessage::kTabs, PermissionMessage::kFavicon});
   // Tabs already allows reading the list of most frequently visited sites.
   kSuppressList.insert(
       {PermissionMessage::kTabs, PermissionMessage::kTopSites});
 
   PermissionMsgSet host_msgs =
       GetHostPermissionMessages(permissions, NULL, extension_type);
-  PermissionMsgSet api_msgs = GetAPIPermissionMessages(permissions, NULL);
+  PermissionMsgSet api_msgs =
+      GetAPIPermissionMessages(permissions, NULL, extension_type);
   PermissionMsgSet manifest_permission_msgs =
       GetManifestPermissionMessages(permissions, NULL);
   messages.insert(messages.end(), host_msgs.begin(), host_msgs.end());
   messages.insert(messages.end(), api_msgs.begin(), api_msgs.end());
   messages.insert(messages.end(), manifest_permission_msgs.begin(),
                   manifest_permission_msgs.end());
 
   for (std::multimap<PermissionMessage::ID,
                      PermissionMessage::ID>::const_iterator it =
            kSuppressList.begin();
        it != kSuppressList.end();
        ++it) {
     SuppressMessage(messages, it->first, it->second);
   }
 
   return messages;
 }
 
-PermissionMessageStrings
-ChromePermissionMessageProvider::GetPermissionMessageStrings(
-    const PermissionSet* permissions,
-    Manifest::Type extension_type) const {
-  PermissionMessageStrings strings;
-  if (IsNewPermissionMessageSystemEnabled()) {
-    CoalescedPermissionMessages messages = GetCoalescedPermissionMessages(
-        GetAllPermissionIDs(permissions, extension_type));
-    for (const CoalescedPermissionMessage& msg : messages)
-      strings.push_back(PermissionMessageString(msg));
-  } else {
-    std::vector<base::string16> messages =
-        GetLegacyWarningMessages(permissions, extension_type);
-    std::vector<base::string16> details =
-        GetLegacyWarningMessagesDetails(permissions, extension_type);
-    DCHECK_EQ(messages.size(), details.size());
-    for (size_t i = 0; i < messages.size(); i++)
-      strings.push_back(PermissionMessageString(messages[i], details[i]));
-  }
-  return strings;
-}
-
 PermissionMessageIDs
 ChromePermissionMessageProvider::GetLegacyPermissionMessageIDs(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
   PermissionMessageIDs ids;
   for (const PermissionMessage& msg :
-       GetPermissionMessages(permissions, extension_type)) {
+       GetLegacyPermissionMessages(permissions, extension_type)) {
     ids.push_back(msg.id());
   }
   return ids;
 }
 
 CoalescedPermissionMessages
 ChromePermissionMessageProvider::GetCoalescedPermissionMessages(
     const PermissionIDSet& permissions) const {
   std::vector<ChromePermissionMessageRule> rules =
       ChromePermissionMessageRule::GetAllRules();
@@ skipping 56 matching lines @@
   if (old_permissions->HasEffectiveFullAccess())
     return false;
 
   // Otherwise, it's a privilege increase if the new one has full access.
   if (new_permissions->HasEffectiveFullAccess())
     return true;
 
   if (IsHostPrivilegeIncrease(old_permissions, new_permissions, extension_type))
     return true;
 
-  if (IsAPIPrivilegeIncrease(old_permissions, new_permissions))
+  if (IsAPIPrivilegeIncrease(old_permissions, new_permissions, extension_type))
     return true;
 
   if (IsManifestPermissionPrivilegeIncrease(old_permissions, new_permissions))
     return true;
 
   return false;
 }
 
 PermissionIDSet ChromePermissionMessageProvider::GetAllPermissionIDs(
     const PermissionSet* permissions,
     Manifest::Type extension_type) const {
   PermissionIDSet permission_ids;
-  GetAPIPermissionMessages(permissions, &permission_ids);
+  GetAPIPermissionMessages(permissions, &permission_ids, extension_type);
   GetManifestPermissionMessages(permissions, &permission_ids);
   GetHostPermissionMessages(permissions, &permission_ids, extension_type);
   return permission_ids;
 }
 
 std::set<PermissionMessage>
 ChromePermissionMessageProvider::GetAPIPermissionMessages(
     const PermissionSet* permissions,
-    PermissionIDSet* permission_ids) const {
+    PermissionIDSet* permission_ids,
+    Manifest::Type extension_type) const {
   PermissionMsgSet messages;
   for (APIPermissionSet::const_iterator permission_it =
            permissions->apis().begin();
        permission_it != permissions->apis().end(); ++permission_it) {
     if (permission_ids != NULL)
       permission_ids->InsertAll(permission_it->GetPermissions());
     if (permission_it->HasMessages()) {
       PermissionMessages new_messages = permission_it->GetMessages();
       messages.insert(new_messages.begin(), new_messages.end());
     }
   }
 
   // A special hack: The warning message for declarativeWebRequest
   // permissions speaks about blocking parts of pages, which is a
   // subset of what the "<all_urls>" access allows. Therefore we
   // display only the "<all_urls>" warning message if both permissions
   // are required.
   if (permissions->ShouldWarnAllHosts()) {
-    if (permission_ids != NULL)
+    // Platform apps don't show hosts warnings. See crbug.com/255229.
+    if (permission_ids != NULL && extension_type != Manifest::TYPE_PLATFORM_APP)
       permission_ids->insert(APIPermission::kHostsAll);
     messages.erase(
         PermissionMessage(
             PermissionMessage::kDeclarativeWebRequest, base::string16()));
   }
   return messages;
 }
 
 std::set<PermissionMessage>
 ChromePermissionMessageProvider::GetManifestPermissionMessages(
@@ skipping 55 matching lines @@
   }
   return messages;
 }
 
 void ChromePermissionMessageProvider::CoalesceWarningMessages(
     const PermissionSet* permissions,
     Manifest::Type extension_type,
     std::vector<base::string16>* message_strings,
     std::vector<base::string16>* message_details_strings) const {
   PermissionMessages messages =
-      GetPermissionMessages(permissions, extension_type);
+      GetLegacyPermissionMessages(permissions, extension_type);
 
   // WARNING: When modifying a coalescing rule in this list, be sure to also
   // modify the corresponding rule in
   // ChromePermissionMessageProvider::GetCoalescedPermissionMessages().
   // TODO(sashab): Deprecate this function, and remove this list.
   for (PermissionMessages::const_iterator i = messages.begin();
        i != messages.end(); ++i) {
     int id = i->id();
     // Access to users' devices should provide a single warning message
     // specifying the transport method used; serial and/or Bluetooth.
@@ skipping 89 matching lines @@
       continue;
     }
 
     message_strings->push_back(i->message());
     message_details_strings->push_back(i->details());
   }
 }
 
 bool ChromePermissionMessageProvider::IsAPIPrivilegeIncrease(
     const PermissionSet* old_permissions,
-    const PermissionSet* new_permissions) const {
+    const PermissionSet* new_permissions,
+    Manifest::Type extension_type) const {
   if (new_permissions == NULL)
     return false;
 
   PermissionMsgSet old_warnings =
-      GetAPIPermissionMessages(old_permissions, NULL);
+      GetAPIPermissionMessages(old_permissions, NULL, extension_type);
   PermissionMsgSet new_warnings =
-      GetAPIPermissionMessages(new_permissions, NULL);
+      GetAPIPermissionMessages(new_permissions, NULL, extension_type);
   PermissionMsgSet delta_warnings =
       base::STLSetDifference<PermissionMsgSet>(new_warnings, old_warnings);
 
   // A special hack: kFileSystemWriteDirectory implies kFileSystemDirectory.
   // TODO(sammc): Remove this. See http://crbug.com/284849.
   if (old_warnings.find(PermissionMessage(
           PermissionMessage::kFileSystemWriteDirectory, base::string16())) !=
       old_warnings.end()) {
     delta_warnings.erase(
         PermissionMessage(PermissionMessage::kFileSystemDirectory,
@@ skipping 50 matching lines @@
   std::set<std::string> old_hosts_set(
       permission_message_util::GetDistinctHosts(old_list, false, false));
   std::set<std::string> new_hosts_only =
       base::STLSetDifference<std::set<std::string> >(new_hosts_set,
                                                      old_hosts_set);
 
   return !new_hosts_only.empty();
 }
 
 }  // namespace extensions