src/xwalk/extensions/test/xwalk_extensions_browsertest.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 "xwalk/extensions/common/xwalk_extension.h"
   8 #include "xwalk/runtime/browser/runtime.h"
   9 #include "xwalk/test/base/in_process_browser_test.h"
  10 #include "xwalk/test/base/xwalk_test_utils.h"
  11 #include "content/public/test/browser_test_utils.h"
  12 #include "content/public/test/test_utils.h"
  13 #include "base/task_runner.h"
  14 #include "base/time/time.h"
  15
  16 using namespace xwalk::extensions;  // NOLINT
  17 using xwalk::Runtime;
  18
  19 namespace {
  20
  21 const char* kEchoAPI =
  22     "var echoListener = null;"
  23     "extension.setMessageListener(function(msg) {"
  24     "  if (echoListener instanceof Function) {"
  25     "    echoListener(msg);"
  26     "  };"
  27     "});"
  28     "exports.echo = function(msg, callback) {"
  29     "  echoListener = callback;"
  30     "  extension.postMessage(msg);"
  31     "};"
  32     "exports.syncEcho = function(msg) {"
  33     "  return extension.internal.sendSyncMessage(msg);"
  34     "};";
  35
  36 class EchoContext : public XWalkExtensionInstance {
  37  public:
  38   EchoContext() {
  39   }
  40   void HandleMessage(scoped_ptr<base::Value> msg) override {
  41     PostMessageToJS(msg.Pass());
  42   }
  43   void HandleSyncMessage(scoped_ptr<base::Value> msg) override {
  44     SendSyncReplyToJS(msg.Pass());
  45   }
  46 };
  47
  48 class DelayedEchoContext : public XWalkExtensionInstance {
  49  public:
  50   void HandleMessage(scoped_ptr<base::Value> msg) override {
  51     PostMessageToJS(msg.Pass());
  52   }
  53   void HandleSyncMessage(scoped_ptr<base::Value> msg) override {
  54     base::MessageLoop::current()->PostDelayedTask(
  55         FROM_HERE, base::Bind(&DelayedEchoContext::DelayedReply,
  56                               base::Unretained(this), base::Passed(&msg)),
  57         base::TimeDelta::FromSeconds(1));
  58   }
  59
  60   void DelayedReply(scoped_ptr<base::Value> reply) {
  61     SendSyncReplyToJS(reply.Pass());
  62   }
  63 };
  64
  65 class EchoExtension : public XWalkExtension {
  66  public:
  67   EchoExtension() : XWalkExtension() {
  68     set_name("echo");
  69     set_javascript_api(kEchoAPI);
  70   }
  71
  72   XWalkExtensionInstance* CreateInstance() override {
  73     s_instance_was_created = true;
  74     return new EchoContext();
  75   }
  76
  77   static bool s_instance_was_created;
  78 };
  79
  80 bool EchoExtension::s_instance_was_created = false;
  81
  82 class DelayedEchoExtension : public XWalkExtension {
  83  public:
  84   DelayedEchoExtension() : XWalkExtension() {
  85     set_name("echo");
  86     set_javascript_api(kEchoAPI);
  87   }
  88
  89   XWalkExtensionInstance* CreateInstance() override {
  90     return new DelayedEchoContext();
  91   }
  92 };
  93
  94 class ExtensionWithInvalidName : public XWalkExtension {
  95  public:
  96   ExtensionWithInvalidName() : XWalkExtension() {
  97     set_name("invalid name with spaces");
  98   }
  99
 100   XWalkExtensionInstance* CreateInstance() override {
 101     s_instance_was_created = true;
 102     return NULL;
 103   }
 104
 105   static bool s_instance_was_created;
 106 };
 107
 108 bool ExtensionWithInvalidName::s_instance_was_created = false;
 109
 110 static const char* kBulkDataAPI = "var bulkDataListener = null;"
 111 ""
 112 "extension.setMessageListener(function(msg) {"
 113 "  if (bulkDataListener instanceof Function) {"
 114 "    bulkDataListener(msg);"
 115 "  };"
 116 "});"
 117 ""
 118 "exports.requestBulkDataAsync = function(power, callback) {"
 119 "  bulkDataListener = callback;"
 120 "  extension.postMessage(power.toString());"
 121 "};";
 122
 123 class BulkDataContext : public XWalkExtensionInstance {
 124  public:
 125   BulkDataContext() {
 126   }
 127   void HandleMessage(scoped_ptr<base::Value> msg) override {
 128     std::string message;
 129     msg->GetAsString(&message);
 130     int size = atoi(message.c_str());
 131     std::string data_chunk(size, 'p');
 132     scoped_ptr<base::Value> data(new base::StringValue(data_chunk));
 133     PostMessageToJS(data.Pass());
 134   }
 135 };
 136
 137 class BulkDataExtension : public XWalkExtension {
 138  public:
 139   BulkDataExtension() : XWalkExtension() {
 140     set_name("bulkData");
 141     set_javascript_api(kBulkDataAPI);
 142   }
 143
 144   XWalkExtensionInstance* CreateInstance() override {
 145     return new BulkDataContext();
 146   }
 147 };
 148
 149 }  // namespace
 150
 151 class XWalkExtensionsTest : public XWalkExtensionsTestBase {
 152  public:
 153   void CreateExtensionsForUIThread(
 154       XWalkExtensionVector* extensions) override {
 155     extensions->push_back(new EchoExtension);
 156     extensions->push_back(new ExtensionWithInvalidName);
 157     extensions->push_back(new BulkDataExtension);
 158   }
 159 };
 160
 161 class XWalkExtensionsDelayedTest : public XWalkExtensionsTestBase {
 162  public:
 163   void CreateExtensionsForUIThread(
 164       XWalkExtensionVector* extensions) override {
 165     extensions->push_back(new DelayedEchoExtension);
 166   }
 167 };
 168
 169 IN_PROC_BROWSER_TEST_F(XWalkExtensionsTest, EchoExtension) {
 170   GURL url = GetExtensionsTestURL(base::FilePath(),
 171       base::FilePath().AppendASCII("test_extension.html"));
 172   Runtime* runtime = CreateRuntime();
 173   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 174   title_watcher.AlsoWaitForTitle(kFailString);
 175   xwalk_test_utils::NavigateToURL(runtime, url);
 176   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 177 }
 178
 179 IN_PROC_BROWSER_TEST_F(XWalkExtensionsTest, ExtensionWithInvalidNameIgnored) {
 180   Runtime* runtime = CreateRuntime();
 181   GURL url = GetExtensionsTestURL(base::FilePath(),
 182       base::FilePath().AppendASCII("test_extension.html"));
 183   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 184   title_watcher.AlsoWaitForTitle(kFailString);
 185   xwalk_test_utils::NavigateToURL(runtime, url);
 186   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 187
 188   EXPECT_TRUE(EchoExtension::s_instance_was_created);
 189   EXPECT_FALSE(ExtensionWithInvalidName::s_instance_was_created);
 190 }
 191
 192 IN_PROC_BROWSER_TEST_F(XWalkExtensionsTest, EchoExtensionSync) {
 193   Runtime* runtime = CreateRuntime();
 194   GURL url = GetExtensionsTestURL(base::FilePath(),
 195                                   base::FilePath().AppendASCII(
 196                                       "sync_echo.html"));
 197   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 198   title_watcher.AlsoWaitForTitle(kFailString);
 199   xwalk_test_utils::NavigateToURL(runtime, url);
 200   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 201 }
 202
 203 IN_PROC_BROWSER_TEST_F(XWalkExtensionsDelayedTest, EchoExtensionSync) {
 204   Runtime* runtime = CreateRuntime();
 205   GURL url = GetExtensionsTestURL(base::FilePath(),
 206                                   base::FilePath().AppendASCII(
 207                                       "sync_echo.html"));
 208   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 209   title_watcher.AlsoWaitForTitle(kFailString);
 210   xwalk_test_utils::NavigateToURL(runtime, url);
 211   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 212 }
 213
 214 IN_PROC_BROWSER_TEST_F(XWalkExtensionsTest, BulkDataExtension) {
 215   Runtime* runtime = CreateRuntime();
 216   GURL url = GetExtensionsTestURL(base::FilePath(),
 217       base::FilePath().AppendASCII("bulk_data_transmission.html"));
 218   content::TitleWatcher title_watcher(runtime->web_contents(), kPassString);
 219   title_watcher.AlsoWaitForTitle(kFailString);
 220   xwalk_test_utils::NavigateToURL(runtime, url);
 221   EXPECT_EQ(kPassString, title_watcher.WaitAndGetTitle());
 222 }