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

media/tools/mfdecoder/main.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.
 
 #ifdef UNICODE
 #undef UNICODE
 #endif
 
 #include <algorithm>
 
 #include <d3d9.h>
 #include <dxva2api.h>
 #include <evr.h>
 #include <mfapi.h>
 #include <mfreadwrite.h>
 #include <windows.h>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
-#include "base/scoped_comptr_win.h"
 #include "base/time.h"
+#include "base/win/scoped_comptr.h"
 #include "media/base/yuv_convert.h"
 #include "media/tools/mfdecoder/mfdecoder.h"
 #include "ui/gfx/gdi_util.h"
 
 static const char* const kWindowClass = "Chrome_MF_Decoder";
 static const char* const kWindowTitle = "MF Decoder";
 static const int kWindowStyleFlags =
     (WS_OVERLAPPEDWINDOW | WS_VISIBLE) & ~(WS_MAXIMIZEBOX | WS_THICKFRAME);
 static bool g_render_to_window = false;
 static bool g_render_asap = false;
@@ skipping 124 matching lines @@
   video_buffer->Unlock();
   return true;
 }
 
 // Obtains the D3D9 surface from the given IMFMediaBuffer, then calls methods
 // in the D3D device to draw to the window associated with it.
 // Returns: true on success.
 static bool PaintD3D9BufferOntoWindow(IDirect3DDevice9* device,
                                       IMFMediaBuffer* video_buffer) {
   CHECK(device != NULL);
-  ScopedComPtr<IDirect3DSurface9> surface;
+  base::win::ScopedComPtr<IDirect3DSurface9> surface;
   HRESULT hr = MFGetService(video_buffer, MR_BUFFER_SERVICE,
                             IID_PPV_ARGS(surface.Receive()));
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get D3D9 surface from buffer";
     return false;
   }
   if (g_render_to_window) {
     base::Time render_start(base::Time::Now());
     hr = device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0),
                        1.0f, 0);
     if (FAILED(hr)) {
       LOG(ERROR) << "Device->Clear() failed";
       return false;
     }
-    ScopedComPtr<IDirect3DSurface9> backbuffer;
+    base::win::ScopedComPtr<IDirect3DSurface9> backbuffer;
     hr = device->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO,
                                backbuffer.Receive());
     if (FAILED(hr)) {
       LOG(ERROR) << "Device->GetBackBuffer() failed";
       return false;
     }
     hr = device->StretchRect(surface.get(), NULL, backbuffer.get(), NULL,
                              D3DTEXF_NONE);
     if (FAILED(hr)) {
       LOG(ERROR) << "Device->StretchRect() failed";
@@ skipping 27 matching lines @@
                             IDirect3DDevice9* device) {
   CHECK(video_window != NULL);
   CHECK(decoder != NULL);
   CHECK(decoder->initialized());
 
   if (decoder->end_of_stream()) {
     LOG(ERROR) << "Failed to obtain more samples from decoder because end of "
                << "stream has been reached";
     return false;
   }
-  ScopedComPtr<IMFSample> video_sample;
+  base::win::ScopedComPtr<IMFSample> video_sample;
   base::Time decode_time_start(base::Time::Now());
   video_sample.Attach(decoder->ReadVideoSample());
   if (video_sample.get() == NULL) {
     LOG(ERROR) << "Failed to obtain a sample from decoder: end of stream? "
                << (decoder->end_of_stream() ? "true" : "false");
     return false;
   }
   *g_decode_time += base::Time::Now() - decode_time_start;
 
   // Get the buffer inside the sample.
   DWORD buffer_count;
   HRESULT hr = video_sample->GetBufferCount(&buffer_count);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get buffer count from sample";
     return false;
   }
 
   // For H.264 videos, the number of buffers in the sample is 1.
   CHECK_EQ(buffer_count, 1u) << "buffer_count should be equal "
                                               << "to 1 for H.264 format";
-  ScopedComPtr<IMFMediaBuffer> video_buffer;
+  base::win::ScopedComPtr<IMFMediaBuffer> video_buffer;
   hr = video_sample->GetBufferByIndex(0, video_buffer.Receive());
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get buffer from sample";
     return false;
   }
   if (decoder->use_dxva2()) {
     return PaintD3D9BufferOntoWindow(device, video_buffer);
   } else {
     return PaintMediaBufferOntoWindow(video_window, video_buffer,
                                       decoder->width(), decoder->height(),
@@ skipping 37 matching lines @@
 // to use the device, and returns the manager. It also initializes the D3D
 // device. This function is used by mfdecoder.cc during the call to
 // MFDecoder::GetDXVA2AttributesForSourceReader().
 // Returns: The D3D manager object if successful. Otherwise, NULL is returned.
 static IDirect3DDeviceManager9* CreateD3DDevManager(HWND video_window,
                                                     IDirect3DDevice9** device) {
   CHECK(video_window != NULL);
   CHECK(device != NULL);
   int ret = -1;
 
-  ScopedComPtr<IDirect3DDeviceManager9> dev_manager;
-  ScopedComPtr<IDirect3D9> d3d;
+  base::win::ScopedComPtr<IDirect3DDeviceManager9> dev_manager;
+  base::win::ScopedComPtr<IDirect3D9> d3d;
   d3d.Attach(Direct3DCreate9(D3D_SDK_VERSION));
   if (d3d == NULL) {
     LOG(ERROR) << "Failed to create D3D9";
     return NULL;
   }
   D3DPRESENT_PARAMETERS present_params = {0};
 
   // Not sure if these values are correct, or if
   // they even matter. (taken from DXVA_HD sample code)
   present_params.BackBufferWidth = 0;
   present_params.BackBufferHeight = 0;
   present_params.BackBufferFormat = D3DFMT_UNKNOWN;
   present_params.BackBufferCount = 1;
   present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
   present_params.hDeviceWindow = video_window;
   present_params.Windowed = TRUE;
   present_params.Flags = D3DPRESENTFLAG_VIDEO;
   present_params.FullScreen_RefreshRateInHz = 0;
   present_params.PresentationInterval = 0;
 
-  ScopedComPtr<IDirect3DDevice9> temp_device;
+  base::win::ScopedComPtr<IDirect3DDevice9> temp_device;
 
   // D3DCREATE_HARDWARE_VERTEXPROCESSING specifies hardware vertex processing.
   HRESULT hr = d3d->CreateDevice(D3DADAPTER_DEFAULT,
                                  D3DDEVTYPE_HAL,
                                  video_window,
                                  (D3DCREATE_HARDWARE_VERTEXPROCESSING |
                                   D3DCREATE_MULTITHREADED),
                                  &present_params,
                                  temp_device.Receive());
   if (FAILED(hr)) {
@@ skipping 130 matching lines @@
                                          : GetDesktopWindow();
   if (video_window == NULL) {
     LOG(ERROR) << "main: Failed to create the video window";
     return -1;
   }
   scoped_ptr<media::MFDecoder> decoder(new media::MFDecoder(use_dxva2));
   if (decoder == NULL) {
     LOG(ERROR) << "Failed to create decoder";
     return -1;
   }
-  ScopedComPtr<IDirect3DDeviceManager9> dev_manager;
-  ScopedComPtr<IDirect3DDevice9> device;
+  base::win::ScopedComPtr<IDirect3DDeviceManager9> dev_manager;
+  base::win::ScopedComPtr<IDirect3DDevice9> device;
   if (decoder->use_dxva2()) {
     dev_manager.Attach(CreateD3DDevManager(video_window, device.Receive()));
     if (dev_manager.get() == NULL || device.get() == NULL) {
       LOG(ERROR) << "DXVA2 specified, but failed to create D3D device";
       return -1;
     }
   }
   if (!decoder->Init(file_name.get(), dev_manager.get())) {
     LOG(ERROR) << "main: Decoder initialization failed";
     return -1;
@@ skipping 52 matching lines @@
           << "\nAverage decode time: " << ((g_num_frames == 0) ?
               0 : (g_decode_time->InMillisecondsF() / g_num_frames))
           << "\nRender time: " << g_render_time->InMilliseconds() << "ms"
           << "\nAverage render time: " << ((g_num_frames == 0) ?
               0 : (g_render_time->InMillisecondsF() / g_num_frames));
   printf("Normal termination\n");
   delete g_decode_time;
   delete g_render_time;
   return 0;
 }