Making the extension permissions dialog scrollable, when needed (adding expandable sections for thi…

chrome/common/extensions/permissions/permission_set_unittest.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 "base/command_line.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 808 matching lines @@
     EXPECT_EQ(kTests[i].expect_success,
               empty->HasAnyAccessToAPI(kTests[i].api_name));
   }
 }
 
 TEST(PermissionsTest, GetWarningMessages_ManyHosts) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("permissions", "many-hosts.json");
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Access your data on encrypted.google.com and www.google.com",
             UTF16ToUTF8(warnings[0]));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Plugins) {
   scoped_refptr<Extension> extension;
   scoped_refptr<PermissionSet> permissions;
 
   extension = LoadManifest("permissions", "plugins.json");
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
 // We don't parse the plugins key on Chrome OS, so it should not ask for any
   // permissions.
 #if defined(OS_CHROMEOS)
   ASSERT_EQ(0u, warnings.size());
 #else
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Access all data on your computer and the websites you visit",
             UTF16ToUTF8(warnings[0]));
 #endif
 }
 
 TEST(PermissionsTest, GetWarningMessages_AudioVideo) {
   // Both audio and video present.
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "audio-video.json");
   PermissionSet* set =
       const_cast<PermissionSet*>(
           extension->GetActivePermissions().get());
   std::vector<string16> warnings =
-      set->GetWarningMessages(extension->GetType());
+      set->GetWarningMessages(extension->GetType(), false);
   EXPECT_FALSE(Contains(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your camera"));
   EXPECT_TRUE(Contains(warnings, "Use your microphone and camera"));
   size_t combined_index = IndexOf(warnings, "Use your microphone and camera");
   size_t combined_size = warnings.size();
 
   // Just audio present.
   set->apis_.erase(APIPermission::kVideoCapture);
-  warnings = set->GetWarningMessages(extension->GetType());
+  warnings = set->GetWarningMessages(extension->GetType(), false);
   EXPECT_EQ(combined_size, warnings.size());
   EXPECT_EQ(combined_index, IndexOf(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your camera"));
   EXPECT_FALSE(Contains(warnings, "Use your microphone and camera"));
 
   // Just video present.
   set->apis_.erase(APIPermission::kAudioCapture);
   set->apis_.insert(APIPermission::kVideoCapture);
-  warnings = set->GetWarningMessages(extension->GetType());
+  warnings = set->GetWarningMessages(extension->GetType(), false);
   EXPECT_EQ(combined_size, warnings.size());
   EXPECT_FALSE(Contains(warnings, "Use your microphone"));
   EXPECT_FALSE(Contains(warnings, "Use your microphone and camera"));
   EXPECT_TRUE(Contains(warnings, "Use your camera"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Serial) {
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "serial.json");
 
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSerial));
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
   EXPECT_TRUE(
       Contains(warnings, "Use serial devices attached to your computer"));
   ASSERT_EQ(1u, warnings.size());
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_AnyHost) {
   Feature::ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_any_host.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSocket));
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
   EXPECT_EQ(1u, warnings.size());
   EXPECT_TRUE(Contains(warnings, "Exchange data with any computer "
                                  "on the local network or internet"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_OneDomainTwoHostnames) {
   Feature::ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_one_domain_two_hostnames.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSocket));
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
 
   // Verify the warnings, including support for unicode characters, the fact
   // that domain host warnings come before specific host warnings, and the fact
   // that domains and hostnames are in alphabetical order regardless of the
   // order in the manifest file.
   EXPECT_EQ(2u, warnings.size());
   if (warnings.size() > 0)
     EXPECT_EQ(warnings[0],
               UTF8ToUTF16("Exchange data with any computer in the domain "
                           "example.org"));
   if (warnings.size() > 1)
     EXPECT_EQ(warnings[1],
               UTF8ToUTF16("Exchange data with the computers named: "
                           "b\xC3\xA5r.example.com foo.example.com"));
                           // "\xC3\xA5" = UTF-8 for lowercase A with ring above
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_TwoDomainsOneHostname) {
   Feature::ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_two_domains_one_hostname.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSocket));
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
 
   // Verify the warnings, including the fact that domain host warnings come
   // before specific host warnings and the fact that domains and hostnames are
   // in alphabetical order regardless of the order in the manifest file.
   EXPECT_EQ(2u, warnings.size());
   if (warnings.size() > 0)
     EXPECT_EQ(warnings[0],
               UTF8ToUTF16("Exchange data with any computer in the domains: "
                            "example.com foo.example.org"));
   if (warnings.size() > 1)
     EXPECT_EQ(warnings[1],
               UTF8ToUTF16("Exchange data with the computer named "
                            "bar.example.org"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_PlatformApppHosts) {
   scoped_refptr<Extension> extension;
 
   extension = LoadManifest("permissions", "platform_app_hosts.json");
   EXPECT_TRUE(extension->is_platform_app());
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
   ASSERT_EQ(0u, warnings.size());
 
   extension = LoadManifest("permissions", "platform_app_all_urls.json");
   EXPECT_TRUE(extension->is_platform_app());
-  warnings = PermissionsData::GetPermissionMessageStrings(extension.get());
+  warnings = PermissionsData::GetPermissionMessageStrings(
+      extension.get(), false);
   ASSERT_EQ(0u, warnings.size());
 }
 
 TEST(PermissionsTest, GetDistinctHostsForDisplay) {
   scoped_refptr<PermissionSet> perm_set;
   APIPermissionSet empty_perms;
   std::set<std::string> expected;
   expected.insert("www.foo.com");
   expected.insert("www.bar.com");
   expected.insert("www.baz.com");
@@ skipping 380 matching lines @@
 }
 
 TEST(PermissionsTest, SyncFileSystemPermission) {
   scoped_refptr<Extension> extension = LoadManifest(
       "permissions", "sync_file_system.json");
   APIPermissionSet apis;
   apis.insert(APIPermission::kSyncFileSystem);
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(extension->HasAPIPermission(APIPermission::kSyncFileSystem));
   std::vector<string16> warnings =
-      PermissionsData::GetPermissionMessageStrings(extension.get());
+      PermissionsData::GetPermissionMessageStrings(extension.get(), false);
   EXPECT_TRUE(Contains(warnings, "Store data in your Google Drive account"));
   ASSERT_EQ(1u, warnings.size());
 }
 
 // Make sure that we don't crash when we're trying to show the permissions
 // even though chrome://thumb (and everything that's not chrome://favicon with
 // a chrome:// scheme) is not a valid permission.
 // More details here: crbug/246314.
 TEST(PermissionsTest, ChromeURLs) {
   URLPatternSet allowed_hosts;
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "http://www.google.com/"));
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "chrome://favicon/"));
   allowed_hosts.AddPattern(
       URLPattern(URLPattern::SCHEME_ALL, "chrome://thumb/"));
   scoped_refptr<PermissionSet> permissions(
       new PermissionSet(APIPermissionSet(), allowed_hosts, URLPatternSet()));
-  permissions->GetPermissionMessages(Manifest::TYPE_EXTENSION);
+  permissions->GetPermissionMessages(Manifest::TYPE_EXTENSION, false);
 }
 
 }  // namespace extensions