Checking in the initial version of CEEE (Chrome Extensions Execution

Environment), an optional feature of Chrome Frame that acts as an
adapter layer for a subset of the Chrome Extension APIs. This enables
extensions that stick to the supported subset of APIs to work in the
context of Chrome Frame with minimal or sometimes no changes.

See http://www.chromium.org/developers/design-documents/ceee for an
overview of the design of CEEE.

TEST=unit tests (run ceee/smoke_tests.bat as an administrator on Windows)
BUG=none



git-svn-id: svn://svn.chromium.org/chrome/trunk/src@64712 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 197 insertions, 0 deletions

diff --git a/ceee/ie/plugin/bho/dom_utils_unittest.cc b/ceee/ie/plugin/bho/dom_utils_unittest.cc
new file mode 100644
index 0000000..180c1cc
--- /dev/null
+++ b/ceee/ie/plugin/bho/dom_utils_unittest.cc
@@ -0,0 +1,197 @@
+// Copyright (c) 2010 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.
+//
+// Unittests for DOM utils.
+#include "ceee/ie/plugin/bho/dom_utils.h"
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "ceee/common/initializing_coclass.h"
+#include "ceee/testing/utils/mshtml_mocks.h"
+#include "ceee/testing/utils/test_utils.h"
+
+namespace {
+
+using testing::_;
+using testing::CopyInterfaceToArgument;
+using testing::DoAll;
+using testing::Return;
+using testing::SetArgumentPointee;
+using testing::StrictMock;
+using testing::StrEq;
+using testing::VariantEq;
+
+class MockDocument
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public InitializingCoClass<MockDocument>,
+      public StrictMock<IHTMLDocument2MockImpl>,
+      public StrictMock<IHTMLDocument3MockImpl> {
+ public:
+  BEGIN_COM_MAP(MockDocument)
+    COM_INTERFACE_ENTRY2(IDispatch, IHTMLDocument2)
+    COM_INTERFACE_ENTRY(IHTMLDocument)
+    COM_INTERFACE_ENTRY(IHTMLDocument2)
+    COM_INTERFACE_ENTRY(IHTMLDocument3)
+  END_COM_MAP()
+
+  HRESULT Initialize(MockDocument** self) {
+    *self = this;
+    return S_OK;
+  }
+};
+
+class MockElementNode
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public InitializingCoClass<MockElementNode>,
+      public StrictMock<IHTMLElementMockImpl>,
+      public StrictMock<IHTMLDOMNodeMockImpl> {
+  BEGIN_COM_MAP(MockElementNode)
+    COM_INTERFACE_ENTRY2(IDispatch, IHTMLElement)
+    COM_INTERFACE_ENTRY(IHTMLElement)
+    COM_INTERFACE_ENTRY(IHTMLDOMNode)
+  END_COM_MAP()
+
+  HRESULT Initialize(MockElementNode** self) {
+    *self = this;
+    return S_OK;
+  }
+};
+
+class MockStyleElementNode
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public InitializingCoClass<MockStyleElementNode>,
+      public StrictMock<IHTMLElementMockImpl>,
+      public StrictMock<IHTMLStyleElementMockImpl>,
+      public StrictMock<IHTMLDOMNodeMockImpl> {
+  BEGIN_COM_MAP(MockStyleElementNode)
+    COM_INTERFACE_ENTRY2(IDispatch, IHTMLElement)
+    COM_INTERFACE_ENTRY(IHTMLElement)
+    COM_INTERFACE_ENTRY(IHTMLStyleElement)
+    COM_INTERFACE_ENTRY(IHTMLDOMNode)
+  END_COM_MAP()
+
+  HRESULT Initialize(MockStyleElementNode** self) {
+    *self = this;
+    return S_OK;
+  }
+};
+
+class MockStyleSheet
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public InitializingCoClass<MockStyleSheet>,
+      public StrictMock<IHTMLStyleSheetMockImpl> {
+  BEGIN_COM_MAP(MockStyleSheet)
+    COM_INTERFACE_ENTRY(IDispatch)
+    COM_INTERFACE_ENTRY(IHTMLStyleSheet)
+  END_COM_MAP()
+
+  HRESULT Initialize(MockStyleSheet** self) {
+    *self = this;
+    return S_OK;
+  }
+};
+
+class DomUtilsTest: public testing::Test {
+ public:
+  virtual void SetUp() {
+    ASSERT_HRESULT_SUCCEEDED(
+        MockDocument::CreateInitialized(&document_, &document_keeper_));
+    ASSERT_HRESULT_SUCCEEDED(
+        MockElementNode::CreateInitialized(&head_node_, &head_node_keeper_));
+  }
+
+  virtual void TearDown() {
+    document_ = NULL;
+    document_keeper_.Release();
+    head_node_ = NULL;
+    head_node_keeper_.Release();
+  }
+
+ protected:
+  MockDocument* document_;
+  CComPtr<IHTMLDocument2> document_keeper_;
+
+  MockElementNode* head_node_;
+  CComPtr<IHTMLDOMNode> head_node_keeper_;
+};
+
+TEST_F(DomUtilsTest, InjectStyleTag) {
+  MockStyleElementNode* style_node;
+  CComPtr<IHTMLElement> style_node_keeper;
+  ASSERT_HRESULT_SUCCEEDED(
+      MockStyleElementNode::CreateInitialized(&style_node, &style_node_keeper));
+
+  MockStyleSheet* style_sheet;
+  CComPtr<IHTMLStyleSheet> style_sheet_keeper;
+  ASSERT_HRESULT_SUCCEEDED(
+      MockStyleSheet::CreateInitialized(&style_sheet, &style_sheet_keeper));
+
+  EXPECT_CALL(*document_, createElement(StrEq(L"style"), _)).
+      WillOnce(DoAll(CopyInterfaceToArgument<1>(style_node_keeper),
+                     Return(S_OK)));
+
+  EXPECT_CALL(*style_node, put_type(StrEq(L"text/css"))).
+      WillOnce(Return(S_OK));
+
+  EXPECT_CALL(*style_node, get_styleSheet(_)).
+      WillOnce(DoAll(CopyInterfaceToArgument<0>(style_sheet_keeper),
+                     Return(S_OK)));
+
+  EXPECT_CALL(*style_sheet, put_cssText(StrEq(L"foo"))).WillOnce(Return(S_OK));
+
+  EXPECT_CALL(*head_node_, appendChild(style_node, _)).
+      WillOnce(Return(S_OK));
+
+  ASSERT_HRESULT_SUCCEEDED(
+      DomUtils::InjectStyleTag(document_keeper_, head_node_keeper_, L"foo"));
+}
+
+class MockElementCollection
+    : public CComObjectRootEx<CComSingleThreadModel>,
+      public InitializingCoClass<MockElementCollection>,
+      public StrictMock<IHTMLElementCollectionMockImpl> {
+ public:
+  BEGIN_COM_MAP(MockElementCollection)
+    COM_INTERFACE_ENTRY(IDispatch)
+    COM_INTERFACE_ENTRY(IHTMLElementCollection)
+  END_COM_MAP()
+
+  HRESULT Initialize(MockElementCollection** self) {
+    *self = this;
+    return S_OK;
+  }
+};
+
+TEST_F(DomUtilsTest, GetHeadNode) {
+  MockElementCollection* collection;
+  CComPtr<IHTMLElementCollection> collection_keeper;
+  ASSERT_HRESULT_SUCCEEDED(
+      MockElementCollection::CreateInitialized(&collection,
+                                               &collection_keeper));
+
+  EXPECT_CALL(*document_, getElementsByTagName(StrEq(L"head"), _))
+      .WillRepeatedly(DoAll(CopyInterfaceToArgument<1>(collection_keeper),
+                            Return(S_OK)));
+
+  CComVariant zero(0L);
+  // First verify that we gracefuly fail when there are no heads.
+  // bb2333090
+  EXPECT_CALL(*collection, item(_, VariantEq(zero), _))
+      .WillOnce(Return(S_OK));
+
+  CComPtr<IHTMLDOMNode> head_node;
+  ASSERT_HRESULT_FAILED(DomUtils::GetHeadNode(document_, &head_node));
+  ASSERT_EQ(static_cast<IHTMLDOMNode*>(NULL), head_node);
+
+  // And now properly return a valid head node.
+  EXPECT_CALL(*collection, item(_, VariantEq(zero), _))
+      .WillOnce(DoAll(CopyInterfaceToArgument<2>(
+          static_cast<IDispatch*>(head_node_keeper_)), Return(S_OK)));
+
+  ASSERT_HRESULT_SUCCEEDED(
+      DomUtils::GetHeadNode(document_, &head_node));
+
+  ASSERT_TRUE(head_node == head_node_);
+}
+
+}  // namespace