Home | History | Annotate | Download | only in manifest_handlers 
      1 // Copyright 2013 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/manifest_handlers/settings_overrides_handler.h"
      6 
      7 #include "base/json/json_string_value_serializer.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "chrome/common/extensions/manifest_url_handler.h"
     10 #include "extensions/common/error_utils.h"
     11 #include "extensions/common/extension.h"
     12 #include "extensions/common/manifest_constants.h"
     13 #include "testing/gtest/include/gtest/gtest.h"
     14 
     15 namespace {
     16 
     17 const char kManifest[] = "{"
     18     " \"version\" : \"1.0.0.0\","
     19     " \"name\" : \"Test\","
     20     " \"chrome_settings_overrides\" : {"
     21     "   \"homepage\" : \"http://www.homepage.com\","
     22     "   \"search_provider\" : {"
     23     "        \"name\" : \"first\","
     24     "        \"keyword\" : \"firstkey\","
     25     "        \"search_url\" : \"http://www.foo.com/s?q={searchTerms}\","
     26     "        \"favicon_url\" : \"http://www.foo.com/favicon.ico\","
     27     "        \"suggest_url\" : \"http://www.foo.com/s?q={searchTerms}\","
     28     "        \"encoding\" : \"UTF-8\","
     29     "        \"is_default\" : true"
     30     "    },"
     31     "   \"startup_pages\" : [\"http://www.startup.com\"]"
     32     "  }"
     33     "}";
     34 
     35 const char kPrepopulatedManifest[] =
     36     "{"
     37     " \"version\" : \"1.0.0.0\","
     38     " \"name\" : \"Test\","
     39     " \"chrome_settings_overrides\" : {"
     40     "   \"search_provider\" : {"
     41     "        \"search_url\" : \"http://www.foo.com/s?q={searchTerms}\","
     42     "        \"prepopulated_id\" : 3,"
     43     "        \"is_default\" : true"
     44     "    }"
     45     "  }"
     46     "}";
     47 
     48 const char kBrokenManifest[] = "{"
     49     " \"version\" : \"1.0.0.0\","
     50     " \"name\" : \"Test\","
     51     " \"chrome_settings_overrides\" : {"
     52     "   \"homepage\" : \"{invalid}\","
     53     "   \"search_provider\" : {"
     54     "        \"name\" : \"first\","
     55     "        \"keyword\" : \"firstkey\","
     56     "        \"search_url\" : \"{invalid}/s?q={searchTerms}\","
     57     "        \"favicon_url\" : \"{invalid}/favicon.ico\","
     58     "        \"encoding\" : \"UTF-8\","
     59     "        \"is_default\" : true"
     60     "    },"
     61     "   \"startup_pages\" : [\"{invalid}\"]"
     62     "  }"
     63     "}";
     64 
     65 using extensions::api::manifest_types::ChromeSettingsOverrides;
     66 using extensions::Extension;
     67 using extensions::Manifest;
     68 using extensions::SettingsOverrides;
     69 namespace manifest_keys = extensions::manifest_keys;
     70 
     71 class OverrideSettingsTest : public testing::Test {
     72 };
     73 
     74 
     75 TEST_F(OverrideSettingsTest, ParseManifest) {
     76   std::string manifest(kManifest);
     77   JSONStringValueSerializer json(&manifest);
     78   std::string error;
     79   scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
     80   ASSERT_TRUE(root);
     81   ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
     82   scoped_refptr<Extension> extension = Extension::Create(
     83       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
     84       Manifest::INVALID_LOCATION,
     85       *static_cast<base::DictionaryValue*>(root.get()),
     86       Extension::NO_FLAGS,
     87       &error);
     88   ASSERT_TRUE(extension.get());
     89 #if defined(OS_WIN)
     90   ASSERT_TRUE(extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
     91 
     92   SettingsOverrides* settings_override = static_cast<SettingsOverrides*>(
     93       extension->GetManifestData(manifest_keys::kSettingsOverride));
     94   ASSERT_TRUE(settings_override);
     95   ASSERT_TRUE(settings_override->search_engine);
     96   EXPECT_TRUE(settings_override->search_engine->is_default);
     97   const ChromeSettingsOverrides::Search_provider* search_engine =
     98       settings_override->search_engine.get();
     99   EXPECT_EQ("first", *search_engine->name);
    100   EXPECT_EQ("firstkey", *search_engine->keyword);
    101   EXPECT_EQ("http://www.foo.com/s?q={searchTerms}", search_engine->search_url);
    102   EXPECT_EQ("http://www.foo.com/favicon.ico", *search_engine->favicon_url);
    103   EXPECT_EQ("http://www.foo.com/s?q={searchTerms}",
    104             *search_engine->suggest_url);
    105   EXPECT_EQ("UTF-8", *search_engine->encoding);
    106 
    107   EXPECT_EQ(std::vector<GURL>(1, GURL("http://www.startup.com")),
    108             settings_override->startup_pages);
    109 
    110   ASSERT_TRUE(settings_override->homepage);
    111   EXPECT_EQ(GURL("http://www.homepage.com"), *settings_override->homepage);
    112 #else
    113   EXPECT_FALSE(
    114       extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
    115 #endif
    116 }
    117 
    118 TEST_F(OverrideSettingsTest, ParsePrepopulatedId) {
    119   std::string manifest(kPrepopulatedManifest);
    120   JSONStringValueSerializer json(&manifest);
    121   std::string error;
    122   scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
    123   ASSERT_TRUE(root);
    124   ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
    125   scoped_refptr<Extension> extension =
    126       Extension::Create(base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
    127                         Manifest::INVALID_LOCATION,
    128                         *static_cast<base::DictionaryValue*>(root.get()),
    129                         Extension::NO_FLAGS,
    130                         &error);
    131   ASSERT_TRUE(extension.get());
    132 #if defined(OS_WIN)
    133   ASSERT_TRUE(extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
    134 
    135   SettingsOverrides* settings_override = static_cast<SettingsOverrides*>(
    136       extension->GetManifestData(manifest_keys::kSettingsOverride));
    137   ASSERT_TRUE(settings_override);
    138   ASSERT_TRUE(settings_override->search_engine);
    139   EXPECT_TRUE(settings_override->search_engine->is_default);
    140   const ChromeSettingsOverrides::Search_provider* search_engine =
    141       settings_override->search_engine.get();
    142   ASSERT_TRUE(search_engine->prepopulated_id);
    143   EXPECT_EQ("http://www.foo.com/s?q={searchTerms}", search_engine->search_url);
    144   EXPECT_EQ(3, *search_engine->prepopulated_id);
    145 #else
    146   EXPECT_FALSE(
    147       extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
    148 #endif
    149 }
    150 
    151 TEST_F(OverrideSettingsTest, ParseBrokenManifest) {
    152   std::string manifest(kBrokenManifest);
    153   JSONStringValueSerializer json(&manifest);
    154   std::string error;
    155   scoped_ptr<base::Value> root(json.Deserialize(NULL, &error));
    156   ASSERT_TRUE(root);
    157   ASSERT_TRUE(root->IsType(base::Value::TYPE_DICTIONARY));
    158   scoped_refptr<Extension> extension = Extension::Create(
    159       base::FilePath(FILE_PATH_LITERAL("//nonexistent")),
    160       Manifest::INVALID_LOCATION,
    161       *static_cast<base::DictionaryValue*>(root.get()),
    162       Extension::NO_FLAGS,
    163       &error);
    164 #if defined(OS_WIN)
    165   EXPECT_FALSE(extension);
    166   EXPECT_EQ(
    167       extensions::ErrorUtils::FormatErrorMessage(
    168           extensions::manifest_errors::kInvalidEmptyDictionary,
    169           extensions::manifest_keys::kSettingsOverride),
    170       error);
    171 #else
    172   EXPECT_TRUE(extension.get());
    173   EXPECT_FALSE(
    174       extension->manifest()->HasPath(manifest_keys::kSettingsOverride));
    175 #endif
    176 }
    177 
    178 }  // namespace
    179