| // Copyright (c) 2011 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 <atlbase.h> |
| #include <atlcom.h> |
| |
| #include "base/file_util.h" |
| #include "base/path_service.h" |
| #include "base/win/scoped_comptr.h" |
| #include "chrome_frame/test/chrome_frame_test_utils.h" |
| #include "chrome_frame/test/urlmon_moniker_tests.h" |
| #include "chrome_frame/urlmon_bind_status_callback.h" |
| |
| using chrome_frame_test::ScopedVirtualizeHklmAndHkcu; |
| using testing::Return; |
| using testing::Eq; |
| |
| class MonikerPatchTest : public testing::Test { |
| protected: |
| MonikerPatchTest() { |
| } |
| |
| virtual void SetUp() { |
| DeleteAllSingletons(); |
| PathService::Get(base::DIR_SOURCE_ROOT, &test_file_path_); |
| test_file_path_ = test_file_path_.Append(FILE_PATH_LITERAL("chrome_frame")) |
| .Append(FILE_PATH_LITERAL("test")) |
| .Append(FILE_PATH_LITERAL("data")); |
| } |
| |
| bool ReadFileAsString(const wchar_t* file_name, std::string* file_contents) { |
| EXPECT_TRUE(file_name); |
| base::FilePath file_path = test_file_path_.Append(file_name); |
| return file_util::ReadFileToString(file_path, file_contents); |
| } |
| |
| static bool StringToStream(const std::string& data, IStream** ret) { |
| EXPECT_TRUE(!data.empty()); |
| |
| base::win::ScopedComPtr<IStream> stream; |
| HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, stream.Receive()); |
| EXPECT_HRESULT_SUCCEEDED(hr); |
| if (FAILED(hr)) { |
| return false; |
| } |
| |
| DWORD written = 0; |
| hr = stream->Write(data.c_str(), data.size(), &written); |
| EXPECT_HRESULT_SUCCEEDED(hr); |
| EXPECT_EQ(data.size(), written); |
| |
| bool result = false; |
| if (SUCCEEDED(hr)) { |
| RewindStream(stream); |
| *ret = stream.Detach(); |
| result = true; |
| } |
| |
| return result; |
| } |
| |
| base::FilePath test_file_path_; |
| ScopedVirtualizeHklmAndHkcu virtualized_registry_; |
| }; |
| |
| // Tests the CacheStream class by writing content into a stream object |
| // and verify that reading that stream back |
| TEST_F(MonikerPatchTest, CacheStream) { |
| const char data[] = "ReadStreamCacheTest"; |
| char ret[2 * sizeof(data)] = {0}; |
| DWORD read = 0; |
| |
| // Test 1: empty stream reads nothing |
| CComObjectStackEx<CacheStream> cache_stream1; |
| EXPECT_EQ(S_FALSE, cache_stream1.Read(ret, sizeof(ret), &read)); |
| EXPECT_EQ(0, read); |
| |
| // Test 2: Read from initialized cache |
| CComObjectStackEx<CacheStream> cache_stream2; |
| cache_stream2.Initialize(data, sizeof(data), false); |
| EXPECT_HRESULT_SUCCEEDED(cache_stream2.Read(ret, sizeof(ret), &read)); |
| EXPECT_EQ(sizeof(data), read); |
| EXPECT_EQ(std::string(data), std::string(ret)); |
| |
| read = 0; |
| EXPECT_EQ(E_PENDING, cache_stream2.Read(ret, sizeof(ret), &read)); |
| EXPECT_EQ(0, read); |
| } |
| |
| ACTION_P3(ReadStream, buffer, size, ret) { |
| EXPECT_EQ(TYMED_ISTREAM, arg3->tymed); |
| *ret = arg3->pstm->Read(buffer, *size, size); |
| } |
| |
| // Tests the implementation of BSCBFeedData to feed data to the |
| // specified IBindStatusCallback |
| TEST_F(MonikerPatchTest, BSCBFeedData) { |
| CComObjectStackEx<MockBindStatusCallbackImpl> mock; |
| const char data[] = "ReadStreamCacheTest"; |
| const DWORD size = sizeof(data); |
| const CLIPFORMAT cf = 0xd0d0; |
| const DWORD flags = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION; |
| const DWORD kArbitraryreadSize = 0xdeadbabe; |
| |
| char read_buffer1[size] = {0}, read_buffer2[size] = {0}; |
| DWORD read_size1 = size, read_size2 = kArbitraryreadSize; |
| HRESULT ret1 = E_FAIL, ret2 = E_FAIL; |
| |
| EXPECT_CALL(mock, OnDataAvailable(flags, size, |
| testing::Field(&FORMATETC::cfFormat, cf), |
| testing::Field(&STGMEDIUM::tymed, TYMED_ISTREAM))) |
| .WillOnce(testing::DoAll( |
| ReadStream(read_buffer1, &read_size1, &ret1), |
| ReadStream(read_buffer2, &read_size2, &ret2), |
| Return(S_OK))); |
| |
| EXPECT_HRESULT_SUCCEEDED(CacheStream::BSCBFeedData(&mock, data, size, cf, |
| flags, false)); |
| |
| EXPECT_HRESULT_SUCCEEDED(ret1); |
| EXPECT_STREQ(data, read_buffer1); |
| EXPECT_EQ(size, read_size1); |
| |
| EXPECT_EQ(E_PENDING, ret2); |
| EXPECT_STREQ("", read_buffer2); |
| EXPECT_EQ(kArbitraryreadSize, read_size2); |
| } |
| |
| const wchar_t kSmallHtmlMetaTag[] = L"sub_frame1.html"; |
| const wchar_t kSmallHtmlNoMetaTag[] = L"host_browser.html"; |
| |
| // Test various aspects of the SniffData class |
| TEST_F(MonikerPatchTest, SniffDataMetaTag) { |
| std::string small_html_meta_tag, small_html_no_meta_tag; |
| ASSERT_TRUE(ReadFileAsString(kSmallHtmlMetaTag, &small_html_meta_tag)); |
| ASSERT_TRUE(ReadFileAsString(kSmallHtmlNoMetaTag, &small_html_no_meta_tag)); |
| |
| base::win::ScopedComPtr<IStream> stream_with_meta, stream_no_meta; |
| ASSERT_TRUE(StringToStream(small_html_meta_tag, stream_with_meta.Receive())); |
| ASSERT_TRUE(StringToStream(small_html_no_meta_tag, |
| stream_no_meta.Receive())); |
| |
| // Initialize 2 sniffers 1 with meta tag and 1 without. |
| SniffData sniffer1, sniffer2; |
| EXPECT_HRESULT_SUCCEEDED(sniffer1.InitializeCache(std::wstring())); |
| EXPECT_HRESULT_SUCCEEDED(sniffer2.InitializeCache(std::wstring())); |
| EXPECT_HRESULT_SUCCEEDED(sniffer1.ReadIntoCache(stream_with_meta, true)); |
| EXPECT_HRESULT_SUCCEEDED(sniffer2.ReadIntoCache(stream_no_meta, true)); |
| |
| // Verify renderer type and size read. |
| EXPECT_TRUE(sniffer1.is_chrome()); |
| EXPECT_EQ(SniffData::OTHER, sniffer2.renderer_type()); |
| EXPECT_EQ(small_html_meta_tag.size(), sniffer1.size()); |
| EXPECT_EQ(small_html_no_meta_tag.size(), sniffer2.size()); |
| } |
| |
| // Now test how the data is fed back the the bind status callback. |
| // case 1: callback reads data in 1 read |
| TEST_F(MonikerPatchTest, SniffDataPlayback1) { |
| std::string small_html_meta_tag; |
| base::win::ScopedComPtr<IStream> stream_with_meta; |
| SniffData sniffer; |
| |
| EXPECT_HRESULT_SUCCEEDED(sniffer.InitializeCache(std::wstring())); |
| ASSERT_TRUE(ReadFileAsString(kSmallHtmlMetaTag, &small_html_meta_tag)); |
| ASSERT_TRUE(StringToStream(small_html_meta_tag, stream_with_meta.Receive())); |
| EXPECT_HRESULT_SUCCEEDED(sniffer.ReadIntoCache(stream_with_meta, true)); |
| |
| CComObjectStackEx<MockBindStatusCallbackImpl> mock; |
| const CLIPFORMAT cf = 0xd0d0; |
| const DWORD flags = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION; |
| const DWORD data_size = small_html_meta_tag.size(); |
| |
| DWORD read_size1 = data_size * 2; |
| scoped_ptr<char[]> read_buffer1(new char[read_size1]); |
| ZeroMemory(read_buffer1.get(), read_size1); |
| |
| char read_buffer2[10] = {0}; |
| DWORD read_size2 = sizeof(read_buffer2); |
| HRESULT ret1 = E_FAIL, ret2 = E_FAIL; |
| |
| EXPECT_CALL(mock, OnDataAvailable(flags, data_size, |
| testing::Field(&FORMATETC::cfFormat, cf), |
| testing::Field(&STGMEDIUM::tymed, TYMED_ISTREAM))) |
| .WillOnce(testing::DoAll( |
| ReadStream(read_buffer1.get(), &read_size1, &ret1), |
| ReadStream(read_buffer2, &read_size2, &ret2), |
| Return(S_OK))); |
| |
| EXPECT_HRESULT_SUCCEEDED(sniffer.DrainCache(&mock, flags, cf)); |
| |
| EXPECT_HRESULT_SUCCEEDED(ret1); |
| EXPECT_EQ(small_html_meta_tag, read_buffer1.get()); |
| EXPECT_EQ(data_size, read_size1); |
| |
| EXPECT_EQ(S_FALSE, ret2); |
| EXPECT_STREQ("", read_buffer2); |
| EXPECT_EQ(sizeof(read_buffer2), read_size2); |
| } |
| |
| // case 2: callback reads data in 2 reads. |
| TEST_F(MonikerPatchTest, SniffDataPlayback2) { |
| std::string small_html_meta_tag; |
| base::win::ScopedComPtr<IStream> stream_with_meta; |
| SniffData sniffer; |
| |
| EXPECT_HRESULT_SUCCEEDED(sniffer.InitializeCache(std::wstring())); |
| ASSERT_TRUE(ReadFileAsString(kSmallHtmlMetaTag, &small_html_meta_tag)); |
| ASSERT_TRUE(StringToStream(small_html_meta_tag, stream_with_meta.Receive())); |
| EXPECT_HRESULT_SUCCEEDED(sniffer.ReadIntoCache(stream_with_meta, true)); |
| |
| CComObjectStackEx<MockBindStatusCallbackImpl> mock; |
| const CLIPFORMAT cf = 0xd0d0; |
| const DWORD flags = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION; |
| const DWORD data_size = small_html_meta_tag.size(); |
| |
| DWORD read_size1 = data_size / 2; // First read is half the data. |
| DWORD read_size2 = data_size; // Second read, try to read past data. |
| scoped_ptr<char[]> read_buffer1(new char[read_size1]); |
| scoped_ptr<char[]> read_buffer2(new char[read_size2]); |
| ZeroMemory(read_buffer1.get(), read_size1); |
| ZeroMemory(read_buffer2.get(), read_size2); |
| |
| char read_buffer3[10] = {0}; |
| DWORD read_size3 = sizeof(read_buffer3); |
| HRESULT ret1 = E_FAIL, ret2 = E_FAIL, ret3 = E_FAIL; |
| |
| EXPECT_CALL(mock, OnDataAvailable(flags, data_size, |
| testing::Field(&FORMATETC::cfFormat, cf), |
| testing::Field(&STGMEDIUM::tymed, TYMED_ISTREAM))) |
| .WillOnce(testing::DoAll( |
| ReadStream(read_buffer1.get(), &read_size1, &ret1), |
| ReadStream(read_buffer2.get(), &read_size2, &ret2), |
| ReadStream(read_buffer3, &read_size3, &ret3), |
| Return(S_OK))); |
| |
| EXPECT_HRESULT_SUCCEEDED(sniffer.DrainCache(&mock, flags, cf)); |
| |
| EXPECT_HRESULT_SUCCEEDED(ret1); |
| EXPECT_HRESULT_SUCCEEDED(ret2); |
| EXPECT_EQ(data_size/2, read_size1); |
| EXPECT_EQ(data_size - read_size1, read_size2); |
| |
| std::string data_read; |
| data_read.append(read_buffer1.get(), read_size1); |
| data_read.append(read_buffer2.get(), read_size2); |
| EXPECT_EQ(small_html_meta_tag, data_read); |
| |
| EXPECT_EQ(S_FALSE, ret3); |
| EXPECT_STREQ("", read_buffer3); |
| EXPECT_EQ(sizeof(read_buffer3), read_size3); |
| } |