Home | History | Annotate | Download | only in extension_action 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/common/extensions/api/extension_action/action_info.h"
      6 #include "chrome/common/extensions/extension_builder.h"
      7 #include "chrome/common/extensions/extension_constants.h"
      8 #include "chrome/common/extensions/extension_icon_set.h"
      9 #include "chrome/common/extensions/extension_manifest_constants.h"
     10 #include "chrome/common/extensions/feature_switch.h"
     11 #include "chrome/common/extensions/manifest_tests/extension_manifest_test.h"
     12 #include "extensions/common/install_warning.h"
     13 #include "testing/gmock/include/gmock/gmock.h"
     14 #include "testing/gtest/include/gtest/gtest.h"
     15 
     16 namespace errors = extension_manifest_errors;
     17 
     18 namespace extensions {
     19 
     20 namespace {
     21 
     22 std::vector<InstallWarning> StripMissingFlagWarning(
     23     const std::vector<InstallWarning>& install_warnings) {
     24   std::vector<InstallWarning> result;
     25   for (size_t i = 0; i < install_warnings.size(); ++i) {
     26     if (install_warnings[i].message != errors::kScriptBadgeRequiresFlag)
     27       result.push_back(install_warnings[i]);
     28   }
     29   return result;
     30 }
     31 
     32 class ScriptBadgeManifestTest : public ExtensionManifestTest {
     33 };
     34 
     35 }  // namespace
     36 
     37 TEST_F(ScriptBadgeManifestTest, ScriptBadgeBasic) {
     38   scoped_refptr<Extension> extension(
     39       ExtensionBuilder()
     40       .SetManifest(DictionaryBuilder()
     41                    .Set("manifest_version", 2)
     42                    .Set("name", "my extension")
     43                    .Set("version", "1.0.0.0")
     44                    .Set("description",
     45                         "Check that a simple script_badge section parses")
     46                    .Set("icons", DictionaryBuilder()
     47                         .Set("16", "icon16.png")
     48                         .Set("32", "icon32.png")
     49                         .Set("19", "icon19.png")
     50                         .Set("48", "icon48.png"))
     51                    .Set("script_badge", DictionaryBuilder()
     52                         .Set("default_popup", "popup.html")))
     53       .Build());
     54   ASSERT_TRUE(extension.get());
     55   const ActionInfo* script_badge_info =
     56       ActionInfo::GetScriptBadgeInfo(extension.get());
     57   ASSERT_TRUE(script_badge_info);
     58   EXPECT_THAT(StripMissingFlagWarning(extension->install_warnings()),
     59               testing::ElementsAre(/*empty*/));
     60 
     61   const ExtensionIconSet& default_icon =
     62       script_badge_info->default_icon;
     63   // Should have a default icon set.
     64   ASSERT_FALSE(default_icon.empty());
     65 
     66   // Verify that correct icon paths are registered in default_icon.
     67   EXPECT_EQ(2u, default_icon.map().size());
     68   EXPECT_EQ("icon16.png",
     69             default_icon.Get(extension_misc::EXTENSION_ICON_BITTY,
     70                              ExtensionIconSet::MATCH_EXACTLY));
     71   EXPECT_EQ("icon32.png",
     72             default_icon.Get(2 * extension_misc::EXTENSION_ICON_BITTY,
     73                              ExtensionIconSet::MATCH_EXACTLY));
     74 
     75   EXPECT_EQ("my extension", script_badge_info->default_title);
     76   EXPECT_FALSE(script_badge_info->default_popup_url.is_empty());
     77 }
     78 
     79 TEST_F(ScriptBadgeManifestTest, ScriptBadgeExplicitTitleAndIconsIgnored) {
     80   scoped_refptr<Extension> extension(
     81       ExtensionBuilder()
     82       .SetManifest(DictionaryBuilder()
     83                    .Set("manifest_version", 2)
     84                    .Set("name", "my extension")
     85                    .Set("version", "1.0.0.0")
     86                    .Set("description",
     87                         "Check that a simple script_badge section parses")
     88                    .Set("icons", DictionaryBuilder()
     89                         .Set("16", "icon16.png"))
     90                    .Set("script_badge", DictionaryBuilder()
     91                         .Set("default_title", "Other Extension")
     92                         .Set("default_icon", "malicious.png")))
     93       .Build());
     94   ASSERT_TRUE(extension.get());
     95   const ActionInfo* script_badge_info =
     96       ActionInfo::GetScriptBadgeInfo(extension.get());
     97   ASSERT_TRUE(script_badge_info);
     98 
     99   EXPECT_THAT(StripMissingFlagWarning(extension->install_warnings()),
    100               testing::ElementsAre(
    101                   InstallWarning(InstallWarning::FORMAT_TEXT,
    102                                  errors::kScriptBadgeTitleIgnored),
    103                   InstallWarning(InstallWarning::FORMAT_TEXT,
    104                                  errors::kScriptBadgeIconIgnored)));
    105 
    106   const ExtensionIconSet& default_icon =
    107       script_badge_info->default_icon;
    108   ASSERT_FALSE(default_icon.empty());
    109 
    110   EXPECT_EQ(1u, default_icon.map().size());
    111   EXPECT_EQ("icon16.png",
    112             default_icon.Get(extension_misc::EXTENSION_ICON_BITTY,
    113                              ExtensionIconSet::MATCH_EXACTLY));
    114 
    115   EXPECT_EQ("my extension", script_badge_info->default_title);
    116 }
    117 
    118 TEST_F(ScriptBadgeManifestTest, ScriptBadgeIconFallsBackToPuzzlePiece) {
    119   scoped_refptr<Extension> extension(
    120       ExtensionBuilder()
    121       .SetManifest(DictionaryBuilder()
    122                    .Set("manifest_version", 2)
    123                    .Set("name", "my extension")
    124                    .Set("version", "1.0.0.0")
    125                    .Set("description",
    126                         "Check that a simple script_badge section parses")
    127                    .Set("icons", DictionaryBuilder()
    128                         .Set("128", "icon128.png")))
    129       .Build());
    130   ASSERT_TRUE(extension.get());
    131   const ActionInfo* script_badge_info =
    132       ActionInfo::GetScriptBadgeInfo(extension.get());
    133   ASSERT_TRUE(script_badge_info);
    134   EXPECT_THAT(extension->install_warnings(),
    135               testing::ElementsAre(/*empty*/));
    136 
    137   const ExtensionIconSet& default_icon =
    138       script_badge_info->default_icon;
    139   ASSERT_FALSE(default_icon.empty()) << "Should fall back to the 128px icon.";
    140   EXPECT_EQ(2u, default_icon.map().size());
    141   EXPECT_EQ("icon128.png",
    142             default_icon.Get(extension_misc::EXTENSION_ICON_BITTY,
    143                              ExtensionIconSet::MATCH_EXACTLY));
    144   EXPECT_EQ("icon128.png",
    145             default_icon.Get(2 * extension_misc::EXTENSION_ICON_BITTY,
    146                              ExtensionIconSet::MATCH_EXACTLY));
    147 }
    148 
    149 }  // namespace extensions
    150