Showing devices transport method in one device

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"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_test_util.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permission_message_util.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/permissions/socket_permission.h"
 #include "extensions/common/value_builder.h"
 #include "grit/generated_resources.h"
+#include "grit/extensions_strings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extension_test_util::LoadManifest;
 
 namespace extensions {
 
 namespace {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
@@ skipping 867 matching lines @@
         new PermissionSet(api_permissions, ManifestPermissionSet(),
                           URLPatternSet(), URLPatternSet()));
     PermissionMessages messages =
         PermissionMessageProvider::Get()->GetPermissionMessages(
             permissions, Manifest::TYPE_EXTENSION);
     EXPECT_EQ(1u, messages.size());
     EXPECT_EQ(PermissionMessage::kTabs, messages[0].id());
   }
 }
 
+TEST(PermissionsTest, AccessToDevicesMessages) {
+  {
+    APIPermissionSet api_permissions;
+    api_permissions.insert(APIPermission::kUsb);
+    scoped_refptr<PermissionSet> permissions(
+        new PermissionSet(api_permissions,
+                          ManifestPermissionSet(),
+                          URLPatternSet(),
+                          URLPatternSet()));
+    std::vector<base::string16> messages =
+        PermissionMessageProvider::Get()->GetWarningMessages(
+            permissions, Manifest::TYPE_EXTENSION);
+    EXPECT_EQ(1u, messages.size());
+    EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_USB),
+              messages[0]);
+  }
+  {
+    APIPermissionSet api_permissions;
+    api_permissions.insert(APIPermission::kSerial);
+    scoped_refptr<PermissionSet> permissions(
+        new PermissionSet(api_permissions,
+                          ManifestPermissionSet(),
+                          URLPatternSet(),
+                          URLPatternSet()));
+    std::vector<base::string16> messages =
+        PermissionMessageProvider::Get()->GetWarningMessages(
+            permissions, Manifest::TYPE_EXTENSION);
+    EXPECT_EQ(1u, messages.size());
+    EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_SERIAL),
+              messages[0]);
+  }
+  {
+    APIPermissionSet api_permissions;
+    api_permissions.insert(APIPermission::kUsb);
+    api_permissions.insert(APIPermission::kSerial);
+    scoped_refptr<PermissionSet> permissions(
+        new PermissionSet(api_permissions,
+                          ManifestPermissionSet(),
+                          URLPatternSet(),
+                          URLPatternSet()));
+    std::vector<base::string16> messages =
+        PermissionMessageProvider::Get()->GetWarningMessages(
+            permissions, Manifest::TYPE_EXTENSION);
+    EXPECT_EQ(1u, messages.size());
+    EXPECT_EQ(
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_USB_SERIAL),
+        messages[0]);
+  }
+  {
+    scoped_refptr<Extension> extension =
+        LoadManifest("permissions", "access_to_devices_bluetooth.json");
+    const PermissionMessageProvider* provider =
+        PermissionMessageProvider::Get();
+    PermissionSet* set = const_cast<PermissionSet*>(
+        extension->permissions_data()->active_permissions().get());
+    std::vector<base::string16> warnings =
+        provider->GetWarningMessages(set, extension->GetType());
+    EXPECT_EQ(1u, warnings.size());
+    EXPECT_EQ(l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH),
+              warnings[0]);
+
+    // Test Bluetooth and Serial
+    set->apis_.insert(APIPermission::kSerial);
+    warnings = provider->GetWarningMessages(set, extension->GetType());
+    EXPECT_EQ(1u, warnings.size());
+    EXPECT_EQ(l10n_util::GetStringUTF16(
+                  IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_SERIAL),
+              warnings[0]);
+    set->apis_.erase(APIPermission::kSerial);
+
+    // Test USB and Bluetooth
+    set->apis_.insert(APIPermission::kUsb);
+    warnings = provider->GetWarningMessages(set, extension->GetType());
+    EXPECT_EQ(1u, warnings.size());
+    EXPECT_EQ(
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_USB_BLUETOOTH),
+        warnings[0]);
+
+    // Test USB, Bluetooth and Serial
+    set->apis_.insert(APIPermission::kSerial);
+    warnings = provider->GetWarningMessages(set, extension->GetType());
+    EXPECT_EQ(1u, warnings.size());
+    EXPECT_EQ(
+        l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_ALL_DEVICES),
+        warnings[0]);
+  }
+}
+
 TEST(PermissionsTest, MergedFileSystemPermissionComparison) {
   APIPermissionSet write_api_permissions;
   write_api_permissions.insert(APIPermission::kFileSystemWrite);
   scoped_refptr<PermissionSet> write_permissions(
       new PermissionSet(write_api_permissions, ManifestPermissionSet(),
                         URLPatternSet(), URLPatternSet()));
 
   APIPermissionSet directory_api_permissions;
   directory_api_permissions.insert(APIPermission::kFileSystemDirectory);
   scoped_refptr<PermissionSet> directory_permissions(
@@ skipping 172 matching lines @@
 
 TEST(PermissionsTest, GetWarningMessages_Serial) {
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "serial.json");
 
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(
       extension->permissions_data()->HasAPIPermission(APIPermission::kSerial));
   std::vector<base::string16> warnings =
       extension->permissions_data()->GetPermissionMessageStrings();
-  EXPECT_TRUE(
-      Contains(warnings, "Use serial devices attached to your computer"));
+  EXPECT_TRUE(Contains(warnings, "Access your serial device(s)"));
   ASSERT_EQ(1u, warnings.size());
 }
 
 TEST(PermissionsTest, GetWarningMessages_Socket_AnyHost) {
   ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_DEV);
 
   scoped_refptr<Extension> extension =
       LoadManifest("permissions", "socket_any_host.json");
   EXPECT_TRUE(extension->is_platform_app());
   EXPECT_TRUE(
@@ skipping 552 matching lines @@
   scoped_refptr<const PermissionSet> permissions_dwr(
       extension_dwr->permissions_data()->active_permissions());
 
   EXPECT_FALSE(PermissionMessageProvider::Get()->
                    IsPrivilegeIncrease(permissions.get(),
                                        permissions_dwr.get(),
                                        extension->GetType()));
 }
 
 }  // namespace extensions