src/xwalk/extensions/test/conflicting_entry_points.cc

   1 // Copyright (c) 2013 Intel Corporation. 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 "xwalk/extensions/test/xwalk_extensions_test_base.h"
   6
   7 #include "base/values.h"
   8 #include "content/public/test/browser_test_utils.h"
   9 #include "content/public/test/test_utils.h"
  10 #include "xwalk/extensions/common/xwalk_extension.h"
  11 #include "xwalk/runtime/browser/runtime.h"
  12 #include "xwalk/test/base/xwalk_test_utils.h"
  13
  14 using namespace xwalk::extensions;  // NOLINT
  15 using xwalk::Runtime;
  16
  17 namespace {
  18
  19 bool g_clean_extension_loaded = false;
  20 bool g_dirty_extension_loaded = false;
  21
  22 base::ListValue g_clean_entry_points;
  23 base::ListValue g_conflicts_with_name;
  24 base::ListValue g_conflicts_with_entry_points;
  25
  26 }
  27
  28 // We should be prepared against extensions conflicting with each others
  29 // entry points, either by the extension name or by explicit entry points.
  30
  31 class CleanInstance : public XWalkExtensionInstance {
  32  public:
  33   CleanInstance() {
  34     g_clean_extension_loaded = true;
  35   }
  36   virtual void HandleMessage(scoped_ptr<base::Value> msg) OVERRIDE {}
  37 };
  38
  39 class DirtyInstance : public XWalkExtensionInstance {
  40  public:
  41   DirtyInstance() {
  42     g_dirty_extension_loaded = true;
  43   }
  44   virtual void HandleMessage(scoped_ptr<base::Value> msg) OVERRIDE {}
  45 };
  46
  47 class CleanExtension : public XWalkExtension {
  48  public:
  49   CleanExtension() : XWalkExtension() {
  50     set_name("clean");
  51     set_entry_points(std::vector<std::string>(1, std::string("FromClean")));
  52     set_javascript_api("exports.clean_loaded = true;"
  53                        "window.FromClean = true;");
  54   }
  55
  56   virtual XWalkExtensionInstance* CreateInstance() OVERRIDE {
  57     return new CleanInstance;
  58   }
  59 };
  60
  61 class ConflictsWithNameExtension : public XWalkExtension {
  62  public:
  63   ConflictsWithNameExtension() : XWalkExtension() {
  64     set_name("conflicts_with_name");
  65     set_entry_points(std::vector<std::string>(1, std::string("clean")));
  66     set_javascript_api("window.clean = 'fail';");
  67   }
  68
  69   virtual XWalkExtensionInstance* CreateInstance() OVERRIDE {
  70     return new DirtyInstance;
  71   }
  72 };
  73
  74
  75 class ConflictsWithEntryPointExtension
  76     : public XWalkExtension {
  77  public:
  78   ConflictsWithEntryPointExtension() : XWalkExtension() {
  79     set_name("conflicts_with_entry_point");
  80     set_entry_points(std::vector<std::string>(1, std::string("FromClean")));
  81     set_javascript_api("window.FromClean = 'fail';");
  82   }
  83
  84   virtual XWalkExtensionInstance* CreateInstance() OVERRIDE {
  85     return new DirtyInstance;
  86   }
  87 };
  88
  89 class XWalkExtensionsConflictsWithNameTest : public XWalkExtensionsTestBase {
  90  public:
  91   virtual void CreateExtensionsForUIThread(
  92       XWalkExtensionVector* extensions) OVERRIDE {
  93     extensions->push_back(new CleanExtension);
  94     extensions->push_back(new ConflictsWithNameExtension);
  95   }
  96 };
  97
  98 class XWalkExtensionsConflictsWithEntryPointTest
  99     : public XWalkExtensionsTestBase {
 100  public:
 101   virtual void CreateExtensionsForUIThread(
 102       XWalkExtensionVector* extensions) OVERRIDE {
 103     extensions->push_back(new CleanExtension);
 104     extensions->push_back(new ConflictsWithEntryPointExtension);
 105   }
 106 };
 107
 108 IN_PROC_BROWSER_TEST_F(XWalkExtensionsConflictsWithNameTest,
 109                        OnlyCleanInstanceLoaded) {
 110   Runtime* runtime = CreateRuntime();
 111   GURL url = GetExtensionsTestURL(
 112       base::FilePath(),
 113       base::FilePath().AppendASCII("conflicting_names.html"));
 114
 115   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 116   title_watcher.AlsoWaitForTitle(kFailString);
 117   xwalk_test_utils::NavigateToURL(runtime, url);
 118   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 119
 120   EXPECT_TRUE(g_clean_extension_loaded);
 121   EXPECT_FALSE(g_dirty_extension_loaded);
 122 }
 123
 124 IN_PROC_BROWSER_TEST_F(XWalkExtensionsConflictsWithEntryPointTest,
 125                        OnlyCleanInstanceLoaded) {
 126   Runtime* runtime = CreateRuntime();
 127   GURL url = GetExtensionsTestURL(
 128       base::FilePath(),
 129       base::FilePath().AppendASCII("conflicting_names.html"));
 130
 131   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 132   title_watcher.AlsoWaitForTitle(kFailString);
 133   xwalk_test_utils::NavigateToURL(runtime, url);
 134   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 135
 136   EXPECT_TRUE(g_clean_extension_loaded);
 137   EXPECT_FALSE(g_dirty_extension_loaded);
 138 }