Include base/win/scoped_comptr.h instead of base/scoped_comptr_win.h.

chrome_frame/test/urlmon_moniker_unittest.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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/scoped_comptr_win.h"
-#include "chrome_frame/urlmon_bind_status_callback.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());
 
-    ScopedComPtr<IStream> stream;
+    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);
@@ skipping 77 matching lines @@
 
 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));
 
-  ScopedComPtr<IStream> stream_with_meta, stream_no_meta;
+  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;
-  ScopedComPtr<IStream> stream_with_meta;
+  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;
@@ skipping 22 matching lines @@
   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;
-  ScopedComPtr<IStream> stream_with_meta;
+  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;
@@ skipping 28 matching lines @@
 
   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);
 }