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

chrome_frame/test/urlmon_moniker_integration_test.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/scoped_comptr_win.h"
+#include "base/threading/thread.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
-#include "base/threading/thread.h"
 #include "chrome_frame/bho.h"
 //#include "chrome_frame/urlmon_moniker.h"
+#include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/test/test_server.h"
-#include "chrome_frame/test/chrome_frame_test_utils.h"
 #include "chrome_frame/test/urlmon_moniker_tests.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #define GMOCK_MUTANT_INCLUDE_LATE_OBJECT_BINDING
 #include "testing/gmock_mutant.h"
 
 using testing::_;
 using testing::CreateFunctor;
 using testing::Eq;
@@ skipping 143 matching lines @@
       EXPECT_CALL(callback_, OnStopBinding(data_available_response, _))
           .WillOnce(DoAll(QUIT_LOOP(mgr_->loop()), Return(S_OK)));
     } else {
       EXPECT_CALL(callback_, OnStopBinding(data_available_response, _))
           .WillOnce(Return(S_OK));
     }
   }
 
   HRESULT CreateUrlMonikerAndBindToStorage(const wchar_t* url,
                                            IBindCtx** bind_ctx) {
-    ScopedComPtr<IMoniker> moniker;
+    base::win::ScopedComPtr<IMoniker> moniker;
     HRESULT hr = CreateURLMoniker(NULL, url, moniker.Receive());
     EXPECT_TRUE(moniker != NULL);
     if (moniker) {
-      ScopedComPtr<IBindCtx> context;
+      base::win::ScopedComPtr<IBindCtx> context;
       ::CreateAsyncBindCtx(0, callback(), NULL, context.Receive());
       DCHECK(context);
-      ScopedComPtr<IStream> stream;
+      base::win::ScopedComPtr<IStream> stream;
       hr = moniker->BindToStorage(context, NULL, IID_IStream,
           reinterpret_cast<void**>(stream.Receive()));
       if (SUCCEEDED(hr) && bind_ctx)
         *bind_ctx = context.Detach();
     }
     return hr;
   }
 
   IBindStatusCallback* callback() {
     return &callback_;
@@ skipping 12 matching lines @@
   const wchar_t test_url[] = L"http://localhost:43210/";
   UrlmonMonikerTestManager test(test_url);
   UrlmonMonikerTestCallback callback(&test);
 
   RunTestServer server_thread;
   EXPECT_TRUE(server_thread.Start());
 
   callback.SetCallbackExpectations(
       UrlmonMonikerTestCallback::REQUEST_SYNCHRONOUS, S_OK, false);
 
-  ScopedComPtr<IBindCtx> bind_ctx;
+  base::win::ScopedComPtr<IBindCtx> bind_ctx;
   HRESULT hr = callback.CreateUrlMonikerAndBindToStorage(test_url,
                                                          bind_ctx.Receive());
   // The download should have happened synchronously, so we don't expect
   // MK_S_ASYNCHRONOUS or any errors.
   EXPECT_EQ(S_OK, hr);
 
   IBindCtx* release = bind_ctx.Detach();
   EXPECT_EQ(0, release->Release());
 
   server_thread.Stop();
 }
 
 // Tests asynchronously binding to a moniker and downloading the target.
 TEST_F(UrlmonMonikerTest, BindToStorageAsynchronous) {
   const wchar_t test_url[] = L"http://localhost:43210/";
   UrlmonMonikerTestManager test(test_url);
   UrlmonMonikerTestCallback callback(&test);
 
   test_server::SimpleWebServer server(43210);
   test_server::SimpleResponse default_response("/", kTestContent);
   server.AddResponse(&default_response);
 
   callback.SetCallbackExpectations(
       UrlmonMonikerTestCallback::REQUEST_ASYNCHRONOUS, S_OK, true);
 
-  ScopedComPtr<IBindCtx> bind_ctx;
+  base::win::ScopedComPtr<IBindCtx> bind_ctx;
   HRESULT hr = callback.CreateUrlMonikerAndBindToStorage(test_url,
                                                          bind_ctx.Receive());
   EXPECT_EQ(MK_S_ASYNCHRONOUS, hr);
   test.loop().RunFor(kUrlmonMonikerTimeoutSec);
 
   IBindCtx* release = bind_ctx.Detach();
   EXPECT_EQ(0, release->Release());
 }
 
 // Responds with the Chrome mime type.
@@ skipping 30 matching lines @@
   EXPECT_EQ(MK_S_ASYNCHRONOUS, hr);
   test.loop().RunFor(kUrlmonMonikerTimeoutSec);
 
   scoped_refptr<RequestData> request_data(
       test.nav_manager().GetActiveRequestData(test_url));
   EXPECT_TRUE(request_data != NULL);
 
   if (request_data) {
     EXPECT_EQ(request_data->GetCachedContentSize(),
               arraysize(kTestContent) - 1);
-    ScopedComPtr<IStream> stream;
+    base::win::ScopedComPtr<IStream> stream;
     request_data->GetResetCachedContentStream(stream.Receive());
     EXPECT_TRUE(stream != NULL);
     if (stream) {
       char buffer[0xffff];
       DWORD read = 0;
       stream->Read(buffer, sizeof(buffer), &read);
       EXPECT_EQ(read, arraysize(kTestContent) - 1);
       EXPECT_EQ(0, memcmp(buffer, kTestContent, read));
     }
   }
@@ skipping 33 matching lines @@
     callback2.SetCallbackExpectations(
         UrlmonMonikerTestCallback::EXPECT_NO_CALL, S_OK, false);
     hr = callback2.CreateUrlMonikerAndBindToStorage(test_url, NULL);
     // S_OK means that the operation completed synchronously.
     // Otherwise we'd get MK_S_ASYNCHRONOUS.
     EXPECT_EQ(S_OK, hr);
   }
 }
 
 */