The Tor Browser / file comparison
comparison: gfx/skia/trunk/src/utils/win/SkIStream.cpp
gfx/skia/trunk/src/utils/win/SkIStream.cpp
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:6ef6383b6b71 |
|---|---|
| 1 | |
| 2 /* | |
| 3 * Copyright 2011 Google Inc. | |
| 4 * | |
| 5 * Use of this source code is governed by a BSD-style license that can be | |
| 6 * found in the LICENSE file. | |
| 7 */ | |
| 8 | |
| 9 | |
| 10 #define WIN32_LEAN_AND_MEAN | |
| 11 #include <windows.h> | |
| 12 #include <ole2.h> | |
| 13 #include "SkIStream.h" | |
| 14 #include "SkStream.h" | |
| 15 | |
| 16 /** | |
| 17 * SkBaseIStream | |
| 18 */ | |
| 19 SkBaseIStream::SkBaseIStream() : _refcount(1) { } | |
| 20 SkBaseIStream::~SkBaseIStream() { } | |
| 21 | |
| 22 HRESULT STDMETHODCALLTYPE SkBaseIStream::QueryInterface(REFIID iid | |
| 23 , void ** ppvObject) | |
| 24 { | |
| 25 if (NULL == ppvObject) { | |
| 26 return E_INVALIDARG; | |
| 27 } | |
| 28 if (iid == __uuidof(IUnknown) | |
| 29 || iid == __uuidof(IStream) | |
| 30 || iid == __uuidof(ISequentialStream)) | |
| 31 { | |
| 32 *ppvObject = static_cast<IStream*>(this); | |
| 33 AddRef(); | |
| 34 return S_OK; | |
| 35 } else { | |
| 36 *ppvObject = NULL; | |
| 37 return E_NOINTERFACE; | |
| 38 } | |
| 39 } | |
| 40 | |
| 41 ULONG STDMETHODCALLTYPE SkBaseIStream::AddRef(void) { | |
| 42 return (ULONG)InterlockedIncrement(&_refcount); | |
| 43 } | |
| 44 | |
| 45 ULONG STDMETHODCALLTYPE SkBaseIStream::Release(void) { | |
| 46 ULONG res = (ULONG) InterlockedDecrement(&_refcount); | |
| 47 if (0 == res) { | |
| 48 delete this; | |
| 49 } | |
| 50 return res; | |
| 51 } | |
| 52 | |
| 53 // ISequentialStream Interface | |
| 54 HRESULT STDMETHODCALLTYPE SkBaseIStream::Read(void* pv | |
| 55 , ULONG cb | |
| 56 , ULONG* pcbRead) | |
| 57 { return E_NOTIMPL; } | |
| 58 | |
| 59 HRESULT STDMETHODCALLTYPE SkBaseIStream::Write(void const* pv | |
| 60 , ULONG cb | |
| 61 , ULONG* pcbWritten) | |
| 62 { return E_NOTIMPL; } | |
| 63 | |
| 64 // IStream Interface | |
| 65 HRESULT STDMETHODCALLTYPE SkBaseIStream::SetSize(ULARGE_INTEGER) | |
| 66 { return E_NOTIMPL; } | |
| 67 | |
| 68 HRESULT STDMETHODCALLTYPE SkBaseIStream::CopyTo(IStream* | |
| 69 , ULARGE_INTEGER | |
| 70 , ULARGE_INTEGER* | |
| 71 , ULARGE_INTEGER*) | |
| 72 { return E_NOTIMPL; } | |
| 73 | |
| 74 HRESULT STDMETHODCALLTYPE SkBaseIStream::Commit(DWORD) | |
| 75 { return E_NOTIMPL; } | |
| 76 | |
| 77 HRESULT STDMETHODCALLTYPE SkBaseIStream::Revert(void) | |
| 78 { return E_NOTIMPL; } | |
| 79 | |
| 80 HRESULT STDMETHODCALLTYPE SkBaseIStream::LockRegion(ULARGE_INTEGER | |
| 81 , ULARGE_INTEGER | |
| 82 , DWORD) | |
| 83 { return E_NOTIMPL; } | |
| 84 | |
| 85 HRESULT STDMETHODCALLTYPE SkBaseIStream::UnlockRegion(ULARGE_INTEGER | |
| 86 , ULARGE_INTEGER | |
| 87 , DWORD) | |
| 88 { return E_NOTIMPL; } | |
| 89 | |
| 90 HRESULT STDMETHODCALLTYPE SkBaseIStream::Clone(IStream **) | |
| 91 { return E_NOTIMPL; } | |
| 92 | |
| 93 HRESULT STDMETHODCALLTYPE SkBaseIStream::Seek(LARGE_INTEGER liDistanceToMove | |
| 94 , DWORD dwOrigin | |
| 95 , ULARGE_INTEGER* lpNewFilePointer) | |
| 96 { return E_NOTIMPL; } | |
| 97 | |
| 98 HRESULT STDMETHODCALLTYPE SkBaseIStream::Stat(STATSTG* pStatstg | |
| 99 , DWORD grfStatFlag) | |
| 100 { return E_NOTIMPL; } | |
| 101 | |
| 102 | |
| 103 /** | |
| 104 * SkIStream | |
| 105 */ | |
| 106 SkIStream::SkIStream(SkStream* stream, bool unrefOnRelease) | |
| 107 : SkBaseIStream() | |
| 108 , fSkStream(stream) | |
| 109 , fUnrefOnRelease(unrefOnRelease) | |
| 110 , fLocation() | |
| 111 { | |
| 112 this->fSkStream->rewind(); | |
| 113 } | |
| 114 | |
| 115 SkIStream::~SkIStream() { | |
| 116 if (NULL != this->fSkStream && fUnrefOnRelease) { | |
| 117 this->fSkStream->unref(); | |
| 118 } | |
| 119 } | |
| 120 | |
| 121 HRESULT SkIStream::CreateFromSkStream(SkStream* stream | |
| 122 , bool unrefOnRelease | |
| 123 , IStream ** ppStream) | |
| 124 { | |
| 125 if (NULL == stream) { | |
| 126 return E_INVALIDARG; | |
| 127 } | |
| 128 *ppStream = new SkIStream(stream, unrefOnRelease); | |
| 129 return S_OK; | |
| 130 } | |
| 131 | |
| 132 // ISequentialStream Interface | |
| 133 HRESULT STDMETHODCALLTYPE SkIStream::Read(void* pv, ULONG cb, ULONG* pcbRead) { | |
| 134 *pcbRead = static_cast<ULONG>(this->fSkStream->read(pv, cb)); | |
| 135 this->fLocation.QuadPart += *pcbRead; | |
| 136 return (*pcbRead == cb) ? S_OK : S_FALSE; | |
| 137 } | |
| 138 | |
| 139 HRESULT STDMETHODCALLTYPE SkIStream::Write(void const* pv | |
| 140 , ULONG cb | |
| 141 , ULONG* pcbWritten) | |
| 142 { | |
| 143 return STG_E_CANTSAVE; | |
| 144 } | |
| 145 | |
| 146 // IStream Interface | |
| 147 HRESULT STDMETHODCALLTYPE SkIStream::Seek(LARGE_INTEGER liDistanceToMove | |
| 148 , DWORD dwOrigin | |
| 149 , ULARGE_INTEGER* lpNewFilePointer) | |
| 150 { | |
| 151 HRESULT hr = S_OK; | |
| 152 | |
| 153 switch(dwOrigin) { | |
| 154 case STREAM_SEEK_SET: { | |
| 155 if (!this->fSkStream->rewind()) { | |
| 156 hr = E_FAIL; | |
| 157 } else { | |
| 158 size_t skipped = this->fSkStream->skip( | |
| 159 static_cast<size_t>(liDistanceToMove.QuadPart) | |
| 160 ); | |
| 161 this->fLocation.QuadPart = skipped; | |
| 162 if (skipped != liDistanceToMove.QuadPart) { | |
| 163 hr = E_FAIL; | |
| 164 } | |
| 165 } | |
| 166 break; | |
| 167 } | |
| 168 case STREAM_SEEK_CUR: { | |
| 169 size_t skipped = this->fSkStream->skip( | |
| 170 static_cast<size_t>(liDistanceToMove.QuadPart) | |
| 171 ); | |
| 172 this->fLocation.QuadPart += skipped; | |
| 173 if (skipped != liDistanceToMove.QuadPart) { | |
| 174 hr = E_FAIL; | |
| 175 } | |
| 176 break; | |
| 177 } | |
| 178 case STREAM_SEEK_END: { | |
| 179 if (!this->fSkStream->rewind()) { | |
| 180 hr = E_FAIL; | |
| 181 } else { | |
| 182 // FIXME: Should not depend on getLength. | |
| 183 // See https://code.google.com/p/skia/issues/detail?id=1570 | |
| 184 LONGLONG skip = this->fSkStream->getLength() | |
| 185 + liDistanceToMove.QuadPart; | |
| 186 size_t skipped = this->fSkStream->skip(static_cast<size_t>(skip)); | |
| 187 this->fLocation.QuadPart = skipped; | |
| 188 if (skipped != skip) { | |
| 189 hr = E_FAIL; | |
| 190 } | |
| 191 } | |
| 192 break; | |
| 193 } | |
| 194 default: | |
| 195 hr = STG_E_INVALIDFUNCTION; | |
| 196 break; | |
| 197 } | |
| 198 | |
| 199 if (NULL != lpNewFilePointer) { | |
| 200 lpNewFilePointer->QuadPart = this->fLocation.QuadPart; | |
| 201 } | |
| 202 return hr; | |
| 203 } | |
| 204 | |
| 205 HRESULT STDMETHODCALLTYPE SkIStream::Stat(STATSTG* pStatstg | |
| 206 , DWORD grfStatFlag) | |
| 207 { | |
| 208 if (0 == (grfStatFlag & STATFLAG_NONAME)) { | |
| 209 return STG_E_INVALIDFLAG; | |
| 210 } | |
| 211 pStatstg->pwcsName = NULL; | |
| 212 // FIXME: Should not depend on getLength | |
| 213 // See https://code.google.com/p/skia/issues/detail?id=1570 | |
| 214 pStatstg->cbSize.QuadPart = this->fSkStream->getLength(); | |
| 215 pStatstg->clsid = CLSID_NULL; | |
| 216 pStatstg->type = STGTY_STREAM; | |
| 217 pStatstg->grfMode = STGM_READ; | |
| 218 return S_OK; | |
| 219 } | |
| 220 | |
| 221 | |
| 222 /** | |
| 223 * SkIWStream | |
| 224 */ | |
| 225 SkWIStream::SkWIStream(SkWStream* stream) | |
| 226 : SkBaseIStream() | |
| 227 , fSkWStream(stream) | |
| 228 { } | |
| 229 | |
| 230 SkWIStream::~SkWIStream() { | |
| 231 if (NULL != this->fSkWStream) { | |
| 232 this->fSkWStream->flush(); | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 HRESULT SkWIStream::CreateFromSkWStream(SkWStream* stream | |
| 237 , IStream ** ppStream) | |
| 238 { | |
| 239 *ppStream = new SkWIStream(stream); | |
| 240 return S_OK; | |
| 241 } | |
| 242 | |
| 243 // ISequentialStream Interface | |
| 244 HRESULT STDMETHODCALLTYPE SkWIStream::Write(void const* pv | |
| 245 , ULONG cb | |
| 246 , ULONG* pcbWritten) | |
| 247 { | |
| 248 HRESULT hr = S_OK; | |
| 249 bool wrote = this->fSkWStream->write(pv, cb); | |
| 250 if (wrote) { | |
| 251 *pcbWritten = cb; | |
| 252 } else { | |
| 253 *pcbWritten = 0; | |
| 254 hr = S_FALSE; | |
| 255 } | |
| 256 return hr; | |
| 257 } | |
| 258 | |
| 259 // IStream Interface | |
| 260 HRESULT STDMETHODCALLTYPE SkWIStream::Commit(DWORD) { | |
| 261 this->fSkWStream->flush(); | |
| 262 return S_OK; | |
| 263 } | |
| 264 | |
| 265 HRESULT STDMETHODCALLTYPE SkWIStream::Stat(STATSTG* pStatstg | |
| 266 , DWORD grfStatFlag) | |
| 267 { | |
| 268 if (0 == (grfStatFlag & STATFLAG_NONAME)) { | |
| 269 return STG_E_INVALIDFLAG; | |
| 270 } | |
| 271 pStatstg->pwcsName = NULL; | |
| 272 pStatstg->cbSize.QuadPart = 0; | |
| 273 pStatstg->clsid = CLSID_NULL; | |
| 274 pStatstg->type = STGTY_STREAM; | |
| 275 pStatstg->grfMode = STGM_WRITE; | |
| 276 return S_OK; | |
| 277 } |
