chrome_frame/test/urlmon_moniker_unittest.cc

// 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);
    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;
  }

  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);
}