Initial import.

1 files changed, 241 insertions, 0 deletions

diff --git a/chromium/content/renderer/cpp_bound_class_unittest.cc b/chromium/content/renderer/cpp_bound_class_unittest.cc
new file mode 100644
index 00000000000..2c0f75f881c
--- /dev/null
+++ b/chromium/content/renderer/cpp_bound_class_unittest.cc
@@ -0,0 +1,241 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Tests for CppBoundClass, in conjunction with CppBindingExample.  Binds
+// a CppBindingExample class into JavaScript in a custom test shell and tests
+// the binding from the outside by loading JS into the shell.
+
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/common/url_constants.h"
+#include "content/public/renderer/render_view_observer.h"
+#include "content/public/test/render_view_test.h"
+#include "content/test/cpp_binding_example.h"
+#include "third_party/WebKit/public/platform/WebURLRequest.h"
+#include "third_party/WebKit/public/web/WebDocument.h"
+#include "third_party/WebKit/public/web/WebElement.h"
+
+using webkit_glue::CppArgumentList;
+using webkit_glue::CppVariant;
+
+namespace content {
+
+namespace {
+
+class CppBindingExampleSubObject : public CppBindingExample {
+ public:
+  CppBindingExampleSubObject() {
+    sub_value_.Set("sub!");
+    BindProperty("sub_value", &sub_value_);
+  }
+ private:
+  CppVariant sub_value_;
+};
+
+
+class CppBindingExampleWithOptionalFallback : public CppBindingExample {
+ public:
+  CppBindingExampleWithOptionalFallback() {
+    BindProperty("sub_object", sub_object_.GetAsCppVariant());
+  }
+
+  void set_fallback_method_enabled(bool state) {
+    BindFallbackCallback(state ?
+        base::Bind(&CppBindingExampleWithOptionalFallback::fallbackMethod,
+                   base::Unretained(this))
+        : CppBoundClass::Callback());
+  }
+
+  // The fallback method does nothing, but because of it the JavaScript keeps
+  // running when a nonexistent method is called on an object.
+  void fallbackMethod(const CppArgumentList& args, CppVariant* result) {
+  }
+
+ private:
+  CppBindingExampleSubObject sub_object_;
+};
+
+class TestObserver : public RenderViewObserver {
+ public:
+  explicit TestObserver(RenderView* render_view)
+      : RenderViewObserver(render_view) {}
+  virtual void DidClearWindowObject(WebKit::WebFrame* frame) OVERRIDE {
+    example_bound_class_.BindToJavascript(frame, "example");
+  }
+  void set_fallback_method_enabled(bool use_fallback) {
+    example_bound_class_.set_fallback_method_enabled(use_fallback);
+  }
+ private:
+  CppBindingExampleWithOptionalFallback example_bound_class_;
+};
+
+}  // namespace
+
+class CppBoundClassTest : public RenderViewTest {
+ public:
+  CppBoundClassTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    RenderViewTest::SetUp();
+    observer_.reset(new TestObserver(view_));
+    observer_->set_fallback_method_enabled(useFallback());
+
+    WebKit::WebURLRequest url_request;
+    url_request.initialize();
+    url_request.setURL(GURL(kAboutBlankURL));
+
+    GetMainFrame()->loadRequest(url_request);
+    ProcessPendingMessages();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    observer_.reset();
+    RenderViewTest::TearDown();
+  }
+
+  // Executes the specified JavaScript and checks that the resulting document
+  // text is empty.
+  void CheckJavaScriptFailure(const std::string& javascript) {
+    ExecuteJavaScript(javascript.c_str());
+    EXPECT_EQ(
+        "",
+        UTF16ToASCII(GetMainFrame()->document().documentElement().innerText()));
+  }
+
+  void CheckTrue(const std::string& expression) {
+    int was_page_a = -1;
+    string16 check_page_a =
+        ASCIIToUTF16(std::string("Number(") + expression + ")");
+    EXPECT_TRUE(ExecuteJavaScriptAndReturnIntValue(check_page_a, &was_page_a));
+    EXPECT_EQ(1, was_page_a);
+  }
+
+ protected:
+  virtual bool useFallback() {
+    return false;
+  }
+
+ private:
+  scoped_ptr<TestObserver> observer_;
+};
+
+class CppBoundClassWithFallbackMethodTest : public CppBoundClassTest {
+ protected:
+  virtual bool useFallback() OVERRIDE {
+    return true;
+  }
+};
+
+// Ensures that the example object has been bound to JS.
+TEST_F(CppBoundClassTest, ObjectExists) {
+  CheckTrue("typeof window.example == 'object'");
+
+  // An additional check to test our test.
+  CheckTrue("typeof window.invalid_object == 'undefined'");
+}
+
+TEST_F(CppBoundClassTest, PropertiesAreInitialized) {
+  CheckTrue("example.my_value == 10");
+
+  CheckTrue("example.my_other_value == 'Reinitialized!'");
+}
+
+TEST_F(CppBoundClassTest, SubOject) {
+  CheckTrue("typeof window.example.sub_object == 'object'");
+
+  CheckTrue("example.sub_object.sub_value == 'sub!'");
+}
+
+TEST_F(CppBoundClassTest, SetAndGetProperties) {
+  // The property on the left will be set to the value on the right, then
+  // checked to make sure it holds that same value.
+  static const std::string tests[] = {
+    "example.my_value", "7",
+    "example.my_value", "'test'",
+    "example.my_other_value", "3.14",
+    "example.my_other_value", "false",
+    "" // Array end marker: insert additional test pairs before this.
+  };
+
+  for (int i = 0; tests[i] != ""; i += 2) {
+    std::string left = tests[i];
+    std::string right = tests[i + 1];
+    // left = right;
+    std::string js = left;
+    js.append(" = ");
+    js.append(right);
+    js.append(";");
+    ExecuteJavaScript(js.c_str());
+    std::string expression = left;
+    expression += " == ";
+    expression += right;
+    CheckTrue(expression);
+  }
+}
+
+TEST_F(CppBoundClassTest, SetAndGetPropertiesWithCallbacks) {
+  // TODO(dglazkov): fix NPObject issues around failing property setters and
+  // getters and add tests for situations when GetProperty or SetProperty fail.
+  ExecuteJavaScript("example.my_value_with_callback = 10;");
+  CheckTrue("example.my_value_with_callback == 10");
+
+  ExecuteJavaScript("example.my_value_with_callback = 11;");
+  CheckTrue("example.my_value_with_callback == 11");
+
+  CheckTrue("example.same == 42");
+
+  ExecuteJavaScript("example.same = 24;");
+  CheckTrue("example.same == 42");
+}
+
+TEST_F(CppBoundClassTest, InvokeMethods) {
+  // The expression on the left is expected to return the value on the right.
+  static const std::string tests[] = {
+    "example.echoValue(true) == true",
+    "example.echoValue(13) == 13",
+    "example.echoValue(2.718) == 2.718",
+    "example.echoValue('yes') == 'yes'",
+    "example.echoValue() == null",     // Too few arguments
+
+    "example.echoType(false) == true",
+    "example.echoType(19) == 3.14159",
+    "example.echoType(9.876) == 3.14159",
+    "example.echoType('test string') == 'Success!'",
+    "example.echoType() == null",      // Too few arguments
+
+    // Comparing floats that aren't integer-valued is usually problematic due
+    // to rounding, but exact powers of 2 should also be safe.
+    "example.plus(2.5, 18.0) == 20.5",
+    "example.plus(2, 3.25) == 5.25",
+    "example.plus(2, 3) == 5",
+    "example.plus() == null",             // Too few arguments
+    "example.plus(1) == null",            // Too few arguments
+    "example.plus(1, 'test') == null",    // Wrong argument type
+    "example.plus('test', 2) == null",    // Wrong argument type
+    "example.plus('one', 'two') == null", // Wrong argument type
+    "" // Array end marker: insert additional test pairs before this.
+  };
+
+  for (int i = 0; tests[i] != ""; i++)
+    CheckTrue(tests[i]);
+
+  ExecuteJavaScript("example.my_value = 3.25; example.my_other_value = 1.25;");
+  CheckTrue("example.plus(example.my_value, example.my_other_value) == 4.5");
+}
+
+// Tests that invoking a nonexistent method with no fallback method stops the
+// script's execution
+TEST_F(CppBoundClassTest,
+       InvokeNonexistentMethodNoFallback) {
+  std::string js = "example.nonExistentMethod();document.writeln('SUCCESS');";
+  CheckJavaScriptFailure(js);
+}
+
+// Ensures existent methods can be invoked successfully when the fallback method
+// is used
+TEST_F(CppBoundClassWithFallbackMethodTest,
+       InvokeExistentMethodsWithFallback) {
+  CheckTrue("example.echoValue(34) == 34");
+}
+
+}  // namespace content