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