Move the rest of source files from webkit/renderer to content/renderer.

webkit/renderer/cpp_variant_unittest.cc

Index: webkit/renderer/cpp_variant_unittest.cc
diff --git a/webkit/renderer/cpp_variant_unittest.cc b/webkit/renderer/cpp_variant_unittest.cc
deleted file mode 100644
index 1f2d3fe8d3e1837de83d4bc99c4fed093d8c28ea..0000000000000000000000000000000000000000
--- a/webkit/renderer/cpp_variant_unittest.cc
+++ /dev/null
@@ -1,514 +0,0 @@
-// 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.
-
-#include <vector>
-
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/strings/string_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/WebKit/public/web/WebBindings.h"
-#include "webkit/renderer/cpp_variant.h"
-
-using WebKit::WebBindings;
-using webkit_glue::CppVariant;
-
-// Creates a std::string from an NPVariant of string type.  If the NPVariant
-// is not a string, empties the std::string.
-void MakeStdString(const NPVariant& np, std::string* std_string) {
-  if (np.type == NPVariantType_String) {
-    const char* chars =
-        reinterpret_cast<const char*>(np.value.stringValue.UTF8Characters);
-    (*std_string).assign(chars, np.value.stringValue.UTF8Length);
-  } else {
-    (*std_string).clear();
-  }
-}
-
-// Verifies that the actual NPVariant is a string and that its value matches
-// the expected_str.
-void CheckString(const std::string& expected_str, const NPVariant& actual) {
-  EXPECT_EQ(NPVariantType_String, actual.type);
-  std::string actual_str;
-  MakeStdString(actual, &actual_str);
-  EXPECT_EQ(expected_str, actual_str);
-}
-
-// Verifies that both the actual and the expected NPVariants are strings and
-// that their values match.
-void CheckString(const NPVariant& expected, const NPVariant& actual) {
-  EXPECT_EQ(NPVariantType_String, expected.type);
-  std::string expected_str;
-  MakeStdString(expected, &expected_str);
-  CheckString(expected_str, actual);
-}
-
-int g_allocate_call_count = 0;
-int g_deallocate_call_count = 0;
-
-void CheckObject(const NPVariant& actual) {
-  EXPECT_EQ(NPVariantType_Object, actual.type);
-  EXPECT_TRUE(actual.value.objectValue);
-  EXPECT_EQ(1U, actual.value.objectValue->referenceCount);
-  EXPECT_EQ(1, g_allocate_call_count);
-  EXPECT_EQ(0, g_deallocate_call_count);
-}
-
-NPObject* MockNPAllocate(NPP npp, NPClass* aClass) {
-  // This is a mock allocate method that mimics the behavior
-  // of WebBindings::createObject when allocate() is NULL
-
-  ++g_allocate_call_count;
-  // Ignore npp and NPClass
-  return reinterpret_cast<NPObject*>(malloc(sizeof(NPObject)));
-}
-
-void MockNPDeallocate(NPObject* npobj) {
-  // This is a mock deallocate method that mimics the behavior
-  // of NPN_DeallocateObject when deallocate() is NULL
-
-  ++g_deallocate_call_count;
-  free(npobj);
-}
-
-static NPClass void_class = { NP_CLASS_STRUCT_VERSION,
-                              MockNPAllocate,
-                              MockNPDeallocate,
-                              0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-class CppVariantTest : public testing::Test {
-public:
-  CppVariantTest() : npp_(new struct _NPP) {}
-  virtual ~CppVariantTest() {}
-
-  virtual void SetUp() OVERRIDE {
-    WebBindings::registerObjectOwner(npp_.get());
-  }
-
-  virtual void TearDown() OVERRIDE {
-    WebBindings::unregisterObjectOwner(npp_.get());
-  }
-
-  struct _NPP* npp() { return npp_.get(); }
-
-  NPObject* MakeVoidObject() {
-    g_allocate_call_count = 0;
-    g_deallocate_call_count = 0;
-    return WebBindings::createObject(npp_.get(), &void_class);
-  }
-
-private:
-  scoped_ptr<struct _NPP> npp_;
-};
-
-TEST_F(CppVariantTest, NewVariantHasNullType) {
-  CppVariant value;
-  EXPECT_EQ(NPVariantType_Null, value.type);
-}
-
-TEST_F(CppVariantTest, SetNullSetsType) {
-  CppVariant value;
-  value.Set(17);
-  value.SetNull();
-  EXPECT_EQ(NPVariantType_Null, value.type);
-}
-
-TEST_F(CppVariantTest, CopyConstructorDoesDeepCopy) {
-  CppVariant source;
-  source.Set("test string");
-  CppVariant dest = source;
-  EXPECT_EQ(NPVariantType_String, dest.type);
-  EXPECT_EQ(NPVariantType_String, source.type);
-
-  // Ensure that the string was copied, not just the pointer.
-  EXPECT_NE(source.value.stringValue.UTF8Characters,
-    dest.value.stringValue.UTF8Characters);
-
-  CheckString(source, dest);
-}
-
-TEST_F(CppVariantTest, CopyConstructorIncrementsRefCount) {
-  CppVariant source;
-  NPObject *object = MakeVoidObject();
-  source.Set(object);
-  // 2 references so far.
-  EXPECT_EQ(2U, source.value.objectValue->referenceCount);
-
-  CppVariant dest = source;
-  EXPECT_EQ(3U, dest.value.objectValue->referenceCount);
-  EXPECT_EQ(1, g_allocate_call_count);
-  WebBindings::releaseObject(object);
-  source.SetNull();
-  CheckObject(dest);
-}
-
-TEST_F(CppVariantTest, AssignmentDoesDeepCopy) {
-  CppVariant source;
-  source.Set("test string");
-  CppVariant dest;
-  dest = source;
-  EXPECT_EQ(NPVariantType_String, dest.type);
-  EXPECT_EQ(NPVariantType_String, source.type);
-
-  // Ensure that the string was copied, not just the pointer.
-  EXPECT_NE(source.value.stringValue.UTF8Characters,
-    dest.value.stringValue.UTF8Characters);
-
-  CheckString(source, dest);
-}
-
-TEST_F(CppVariantTest, AssignmentIncrementsRefCount) {
-  CppVariant source;
-  NPObject *object = MakeVoidObject();
-  source.Set(object);
-  // 2 references so far.
-  EXPECT_EQ(2U, source.value.objectValue->referenceCount);
-
-  CppVariant dest;
-  dest = source;
-  EXPECT_EQ(3U, dest.value.objectValue->referenceCount);
-  EXPECT_EQ(1, g_allocate_call_count);
-
-  WebBindings::releaseObject(object);
-  source.SetNull();
-  CheckObject(dest);
-}
-
-TEST_F(CppVariantTest, DestroyingCopyDoesNotCorruptSource) {
-  CppVariant source;
-  source.Set("test string");
-  std::string before;
-  MakeStdString(source, &before);
-  {
-    CppVariant dest = source;
-  }
-  CheckString(before, source);
-
-  NPObject *object = MakeVoidObject();
-  source.Set(object);
-  {
-    CppVariant dest2 = source;
-  }
-  WebBindings::releaseObject(object);
-  CheckObject(source);
-}
-
-TEST_F(CppVariantTest, CopiesTypeAndValueToNPVariant) {
-  NPVariant np;
-  CppVariant cpp;
-
-  cpp.Set(true);
-  cpp.CopyToNPVariant(&np);
-  EXPECT_EQ(cpp.type, np.type);
-  EXPECT_EQ(cpp.value.boolValue, np.value.boolValue);
-  WebBindings::releaseVariantValue(&np);
-
-  cpp.Set(17);
-  cpp.CopyToNPVariant(&np);
-  EXPECT_EQ(cpp.type, np.type);
-  EXPECT_EQ(cpp.value.intValue, np.value.intValue);
-  WebBindings::releaseVariantValue(&np);
-
-  cpp.Set(3.1415);
-  cpp.CopyToNPVariant(&np);
-  EXPECT_EQ(cpp.type, np.type);
-  EXPECT_EQ(cpp.value.doubleValue, np.value.doubleValue);
-  WebBindings::releaseVariantValue(&np);
-
-  cpp.Set("test value");
-  cpp.CopyToNPVariant(&np);
-  CheckString("test value", np);
-  WebBindings::releaseVariantValue(&np);
-
-  cpp.SetNull();
-  cpp.CopyToNPVariant(&np);
-  EXPECT_EQ(cpp.type, np.type);
-  WebBindings::releaseVariantValue(&np);
-
-  NPObject *object = MakeVoidObject();
-  cpp.Set(object);
-  cpp.CopyToNPVariant(&np);
-  WebBindings::releaseObject(object);
-  cpp.SetNull();
-  CheckObject(np);
-  WebBindings::releaseVariantValue(&np);
-}
-
-TEST_F(CppVariantTest, SetsTypeAndValueFromNPVariant) {
-  NPVariant np;
-  CppVariant cpp;
-
-  VOID_TO_NPVARIANT(np);
-  cpp.Set(np);
-  EXPECT_EQ(np.type, cpp.type);
-  WebBindings::releaseVariantValue(&np);
-
-  NULL_TO_NPVARIANT(np);
-  cpp.Set(np);
-  EXPECT_EQ(np.type, cpp.type);
-  WebBindings::releaseVariantValue(&np);
-
-  BOOLEAN_TO_NPVARIANT(true, np);
-  cpp.Set(np);
-  EXPECT_EQ(np.type, cpp.type);
-  EXPECT_EQ(np.value.boolValue, cpp.value.boolValue);
-  WebBindings::releaseVariantValue(&np);
-
-  INT32_TO_NPVARIANT(15, np);
-  cpp.Set(np);
-  EXPECT_EQ(np.type, cpp.type);
-  EXPECT_EQ(np.value.intValue, cpp.value.intValue);
-  WebBindings::releaseVariantValue(&np);
-
-  DOUBLE_TO_NPVARIANT(2.71828, np);
-  cpp.Set(np);
-  EXPECT_EQ(np.type, cpp.type);
-  EXPECT_EQ(np.value.doubleValue, cpp.value.doubleValue);
-  WebBindings::releaseVariantValue(&np);
-
-  NPString np_ascii_str = { "1st test value",
-                            static_cast<uint32_t>(strlen("1st test value")) };
-  WebBindings::initializeVariantWithStringCopy(&np, &np_ascii_str);
-  cpp.Set(np);
-  CheckString("1st test value", cpp);
-  WebBindings::releaseVariantValue(&np);
-
-  // Test characters represented in 2/3/4 bytes in UTF-8
-  // Greek alpha, Chinese number 1 (horizontal bar),
-  // Deseret letter (similar to 'O')
-  NPString np_intl_str = { "\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84",
-                           static_cast<uint32_t>(strlen(
-                               "\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84")) };
-  WebBindings::initializeVariantWithStringCopy(&np, &np_intl_str);
-  cpp.Set(np);
-  CheckString("\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84", cpp);
-  WebBindings::releaseVariantValue(&np);
-
-  NPObject *obj = MakeVoidObject();
-  OBJECT_TO_NPVARIANT(obj, np);  // Doesn't make a copy.
-  cpp.Set(np);
-  // Use this or WebBindings::releaseObject but NOT both.
-  WebBindings::releaseVariantValue(&np);
-  CheckObject(cpp);
-}
-
-TEST_F(CppVariantTest, SetsSimpleTypesAndValues) {
-  CppVariant cpp;
-  cpp.Set(true);
-  EXPECT_EQ(NPVariantType_Bool, cpp.type);
-  EXPECT_TRUE(cpp.value.boolValue);
-
-  cpp.Set(5);
-  EXPECT_EQ(NPVariantType_Int32, cpp.type);
-  EXPECT_EQ(5, cpp.value.intValue);
-
-  cpp.Set(1.234);
-  EXPECT_EQ(NPVariantType_Double, cpp.type);
-  EXPECT_EQ(1.234, cpp.value.doubleValue);
-
-  // C string
-  cpp.Set("1st test string");
-  CheckString("1st test string", cpp);
-
-  // std::string
-  std::string source("std test string");
-  cpp.Set(source);
-  CheckString("std test string", cpp);
-
-  // NPString
-  NPString np_ascii_str = { "test NPString",
-                            static_cast<uint32_t>(strlen("test NPString")) };
-  cpp.Set(np_ascii_str);
-  std::string expected("test NPString");
-  CheckString(expected, cpp);
-
-  // Test characters represented in 2/3/4 bytes in UTF-8
-  // Greek alpha, Chinese number 1 (horizontal bar),
-  // Deseret letter (similar to 'O')
-  NPString np_intl_str = { "\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84",
-                           static_cast<uint32_t>(strlen(
-                               "\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84")) };
-  cpp.Set(np_intl_str);
-  expected = std::string("\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84");
-  CheckString(expected, cpp);
-
-  NPObject* obj = MakeVoidObject();
-  cpp.Set(obj);
-  WebBindings::releaseObject(obj);
-  CheckObject(cpp);
-}
-
-TEST_F(CppVariantTest, FreeDataSetsToVoid) {
-  CppVariant cpp;
-  EXPECT_EQ(NPVariantType_Null, cpp.type);
-  cpp.Set(12);
-  EXPECT_EQ(NPVariantType_Int32, cpp.type);
-  cpp.FreeData();
-  EXPECT_EQ(NPVariantType_Void, cpp.type);
-}
-
-TEST_F(CppVariantTest, FreeDataReleasesObject) {
-  CppVariant cpp;
-  NPObject* object = MakeVoidObject();
-  cpp.Set(object);
-  EXPECT_EQ(2U, object->referenceCount);
-  cpp.FreeData();
-  EXPECT_EQ(1U, object->referenceCount);
-  EXPECT_EQ(0, g_deallocate_call_count);
-
-  cpp.Set(object);
-  WebBindings::releaseObject(object);
-  EXPECT_EQ(0, g_deallocate_call_count);
-  cpp.FreeData();
-  EXPECT_EQ(1, g_deallocate_call_count);
-}
-
-TEST_F(CppVariantTest, IsTypeFunctionsWork) {
-  CppVariant cpp;
-  // These should not happen in practice, since voids are not supported
-  // This test must be first since it just clobbers internal data without
-  // releasing.
-  VOID_TO_NPVARIANT(cpp);
-  EXPECT_FALSE(cpp.isBool());
-  EXPECT_FALSE(cpp.isInt32());
-  EXPECT_FALSE(cpp.isDouble());
-  EXPECT_FALSE(cpp.isNumber());
-  EXPECT_FALSE(cpp.isString());
-  EXPECT_TRUE(cpp.isVoid());
-  EXPECT_FALSE(cpp.isNull());
-  EXPECT_TRUE(cpp.isEmpty());
-
-  cpp.Set(true);
-  EXPECT_TRUE(cpp.isBool());
-  EXPECT_FALSE(cpp.isInt32());
-  EXPECT_FALSE(cpp.isDouble());
-  EXPECT_FALSE(cpp.isNumber());
-  EXPECT_FALSE(cpp.isString());
-  EXPECT_FALSE(cpp.isVoid());
-  EXPECT_FALSE(cpp.isNull());
-  EXPECT_FALSE(cpp.isEmpty());
-  EXPECT_FALSE(cpp.isObject());
-
-  cpp.Set(12);
-  EXPECT_FALSE(cpp.isBool());
-  EXPECT_TRUE(cpp.isInt32());
-  EXPECT_FALSE(cpp.isDouble());
-  EXPECT_TRUE(cpp.isNumber());
-  EXPECT_FALSE(cpp.isString());
-  EXPECT_FALSE(cpp.isVoid());
-  EXPECT_FALSE(cpp.isNull());
-  EXPECT_FALSE(cpp.isEmpty());
-  EXPECT_FALSE(cpp.isObject());
-
-  cpp.Set(3.1415);
-  EXPECT_FALSE(cpp.isBool());
-  EXPECT_FALSE(cpp.isInt32());
-  EXPECT_TRUE(cpp.isDouble());
-  EXPECT_TRUE(cpp.isNumber());
-  EXPECT_FALSE(cpp.isString());
-  EXPECT_FALSE(cpp.isVoid());
-  EXPECT_FALSE(cpp.isNull());
-  EXPECT_FALSE(cpp.isEmpty());
-  EXPECT_FALSE(cpp.isObject());
-
-  cpp.Set("a string");
-  EXPECT_FALSE(cpp.isBool());
-  EXPECT_FALSE(cpp.isInt32());
-  EXPECT_FALSE(cpp.isDouble());
-  EXPECT_FALSE(cpp.isNumber());
-  EXPECT_TRUE(cpp.isString());
-  EXPECT_FALSE(cpp.isVoid());
-  EXPECT_FALSE(cpp.isNull());
-  EXPECT_FALSE(cpp.isEmpty());
-  EXPECT_FALSE(cpp.isObject());
-
-  cpp.SetNull();
-  EXPECT_FALSE(cpp.isBool());
-  EXPECT_FALSE(cpp.isInt32());
-  EXPECT_FALSE(cpp.isDouble());
-  EXPECT_FALSE(cpp.isNumber());
-  EXPECT_FALSE(cpp.isString());
-  EXPECT_FALSE(cpp.isVoid());
-  EXPECT_TRUE(cpp.isNull());
-  EXPECT_TRUE(cpp.isEmpty());
-  EXPECT_FALSE(cpp.isObject());
-
-  NPObject *obj = MakeVoidObject();
-  cpp.Set(obj);
-  EXPECT_FALSE(cpp.isBool());
-  EXPECT_FALSE(cpp.isInt32());
-  EXPECT_FALSE(cpp.isDouble());
-  EXPECT_FALSE(cpp.isNumber());
-  EXPECT_FALSE(cpp.isString());
-  EXPECT_FALSE(cpp.isVoid());
-  EXPECT_FALSE(cpp.isNull());
-  EXPECT_FALSE(cpp.isEmpty());
-  EXPECT_TRUE(cpp.isObject());
-  WebBindings::releaseObject(obj);
-  CheckObject(cpp);
-}
-
-bool MockNPHasPropertyFunction(NPObject *npobj, NPIdentifier name) {
-  return true;
-}
-
-bool MockNPGetPropertyFunction(NPObject *npobj, NPIdentifier name,
-                               NPVariant *result) {
-  if (WebBindings::getStringIdentifier("length") == name) {
-    DOUBLE_TO_NPVARIANT(4, *result);
-  } else if (WebBindings::getIntIdentifier(0) == name) {
-    DOUBLE_TO_NPVARIANT(0, *result);
-  } else if (WebBindings::getIntIdentifier(1) == name) {
-    BOOLEAN_TO_NPVARIANT(true, *result);
-  } else if (WebBindings::getIntIdentifier(2) == name) {
-    NULL_TO_NPVARIANT(*result);
-  } else if (WebBindings::getIntIdentifier(3) == name) {
-    const char* s = "string";
-    size_t length = strlen(s);
-    char* mem = static_cast<char*>(malloc(length + 1));
-    base::strlcpy(mem, s, length + 1);
-    STRINGZ_TO_NPVARIANT(mem, *result);
-  }
-
-  return true;
-}
-
-TEST_F(CppVariantTest, ToVector) {
-  NPClass array_like_class = {
-      NP_CLASS_STRUCT_VERSION,
-      0, // NPAllocateFunctionPtr allocate;
-      0, // NPDeallocateFunctionPtr deallocate;
-      0, // NPInvalidateFunctionPtr invalidate;
-      0, // NPHasMethodFunctionPtr hasMethod;
-      0, // NPInvokeFunctionPtr invoke;
-      0, // NPInvokeDefaultFunctionPtr invokeDefault;
-      MockNPHasPropertyFunction, // NPHasPropertyFunctionPtr hasProperty;
-      MockNPGetPropertyFunction, // NPGetPropertyFunctionPtr getProperty;
-      0, // NPSetPropertyFunctionPtr setProperty;
-      0, // NPRemovePropertyFunctionPtr removeProperty;
-      0, // NPEnumerationFunctionPtr enumerate;
-      0 // NPConstructFunctionPtr construct;
-      };
-
-  NPObject* obj = WebBindings::createObject(npp(), &array_like_class);
-
-  CppVariant cpp;
-  cpp.Set(obj);
-
-  std::vector<CppVariant> cpp_vector = cpp.ToVector();
-  EXPECT_EQ(4u, cpp_vector.size());
-
-  EXPECT_TRUE(cpp_vector[0].isDouble());
-  EXPECT_EQ(0, cpp_vector[0].ToDouble());
-
-  EXPECT_TRUE(cpp_vector[1].isBool());
-  EXPECT_EQ(true, cpp_vector[1].ToBoolean());
-
-  EXPECT_TRUE(cpp_vector[2].isNull());
-
-  EXPECT_TRUE(cpp_vector[3].isString());
-  CheckString("string", cpp_vector[3]);
-
-  WebBindings::releaseObject(obj);
-}