TextureImageEGL::TextureImageEGL(GLuint aTexture,
const nsIntSize& aSize,
GLenum aWrapMode,
ContentType aContentType,
GLContext* aContext,
Flags aFlags,
TextureState aTextureState,
TextureImage::ImageFormat aImageFormat)
: TextureImage(aSize, aWrapMode, aContentType, aFlags)
, mGLContext(aContext)
, mUpdateFormat(aImageFormat)
, mEGLImage(nullptr)
, mTexture(aTexture)
, mSurface(nullptr)
, mConfig(nullptr)
, mTextureState(aTextureState)
, mBound(false)
{
if (mUpdateFormat == gfxImageFormat::Unknown) {
mUpdateFormat = gfxPlatform::GetPlatform()->OptimalFormatForContent(GetContentType());
}
if (mUpdateFormat == gfxImageFormat::RGB16_565) {
mTextureFormat = gfx::SurfaceFormat::R8G8B8X8;
} else if (mUpdateFormat == gfxImageFormat::RGB24) {
// RGB24 means really RGBX for Thebes, which means we have to
// use the right shader and ignore the uninitialized alpha
// value.
mTextureFormat = gfx::SurfaceFormat::B8G8R8X8;
} else {
mTextureFormat = gfx::SurfaceFormat::B8G8R8A8;
}
}
TextureImageEGL::TextureImageEGL(GLuint aTexture,
const gfx::IntSize& aSize,
GLenum aWrapMode,
ContentType aContentType,
GLContext* aContext,
Flags aFlags,
TextureState aTextureState,
TextureImage::ImageFormat aImageFormat)
: TextureImage(aSize, aWrapMode, aContentType, aFlags)
, mGLContext(aContext)
, mUpdateFormat(gfx::ImageFormatToSurfaceFormat(aImageFormat))
, mEGLImage(nullptr)
, mTexture(aTexture)
, mSurface(nullptr)
, mConfig(nullptr)
, mTextureState(aTextureState)
, mBound(false)
{
if (mUpdateFormat == gfx::SurfaceFormat::UNKNOWN) {
mUpdateFormat =
gfxPlatform::GetPlatform()->Optimal2DFormatForContent(GetContentType());
}
if (mUpdateFormat == gfx::SurfaceFormat::R5G6B5_UINT16) {
mTextureFormat = gfx::SurfaceFormat::R8G8B8X8;
} else if (mUpdateFormat == gfx::SurfaceFormat::B8G8R8X8) {
mTextureFormat = gfx::SurfaceFormat::B8G8R8X8;
} else {
mTextureFormat = gfx::SurfaceFormat::B8G8R8A8;
}
}
BOOL
MediaSourceImpl::VerifyContentType()
{
if (m_verified_content_type)
return TRUE;
OP_ASSERT(m_use_url->GetAttribute(URL::KMultimedia) != FALSE);
ContentDetector content_detector(m_use_url->GetRep(), TRUE, TRUE);
OP_STATUS status = content_detector.DetectContentType();
if (OpStatus::IsSuccess(status) &&
(content_detector.WasTheCheckDeterministic() || IsLoadedURL(m_use_url)))
{
const char* sniffed_type = GetContentType();
BOOL3 can_play = NO;
status = g_media_module.CanPlayType(&can_play, sniffed_type);
if (OpStatus::IsSuccess(status))
{
if (can_play == NO)
status = OpStatus::ERR_NOT_SUPPORTED;
else
m_verified_content_type = TRUE;
}
}
if (OpStatus::IsError(status))
{
RAISE_IF_MEMORY_ERROR(status);
LoadFailed();
}
return m_verified_content_type;
}
gfx::DrawTarget*
BasicTextureImage::BeginUpdate(nsIntRegion& aRegion)
{
NS_ASSERTION(!mUpdateDrawTarget, "BeginUpdate() without EndUpdate()?");
// determine the region the client will need to repaint
if (CanUploadSubTextures(mGLContext)) {
GetUpdateRegion(aRegion);
} else {
aRegion = IntRect(IntPoint(0, 0), mSize);
}
mUpdateRegion = aRegion;
IntRect rgnSize = mUpdateRegion.GetBounds();
if (!IntRect(IntPoint(0, 0), mSize).Contains(rgnSize)) {
NS_ERROR("update outside of image");
return nullptr;
}
gfx::SurfaceFormat format =
(GetContentType() == gfxContentType::COLOR) ?
gfx::SurfaceFormat::B8G8R8X8 : gfx::SurfaceFormat::B8G8R8A8;
mUpdateDrawTarget =
GetDrawTargetForUpdate(gfx::IntSize(rgnSize.width, rgnSize.height), format);
return mUpdateDrawTarget;
}
bool CWebserverRequest::SendFile(const std::string path,const std::string filename)
{
if( (tmpint = OpenFile(path, filename) ) != -1 )
{ // Wenn Datei geöffnet werden konnte
if (!SocketWrite("HTTP/1.0 200 OK\r\n"))
{
close(tmpint);
return false;
}
HttpStatus = 200;
if (!SocketWrite("Content-Type: " + GetContentType(FileExt) + "\r\n\r\n"))
{
close(tmpint);
return false;
}
if (Method == M_HEAD) {
close(tmpint);
return true;
}
off_t start = 0;
off_t end = lseek(tmpint,0,SEEK_END);
int written = 0;
if((written = sendfile(Socket,tmpint,&start,end)) == -1)
perror("sendfile failed");
close(tmpint);
return true;
}
else
{
Send404Error();
return false;
}
}
NS_IMETHODIMP
WebBrowserPersistLocalDocument::GetContentType(nsACString& aContentType) {
nsAutoString utf16Type;
mDocument->GetContentType(utf16Type);
CopyUTF16toUTF8(utf16Type, aContentType);
return NS_OK;
}
gfx::DrawTarget*
TiledTextureImage::BeginUpdate(nsIntRegion& aRegion)
{
NS_ASSERTION(!mInUpdate, "nested update");
mInUpdate = true;
// Note, we don't call GetUpdateRegion here as if the updated region is
// fully contained in a single tile, we get to avoid iterating through
// the tiles again (and a little copying).
if (mTextureState != Valid)
{
// if the texture hasn't been initialized yet, or something important
// changed, we need to recreate our backing surface and force the
// client to paint everything
aRegion = IntRect(IntPoint(0, 0), mSize);
}
IntRect bounds = aRegion.GetBounds();
for (unsigned i = 0; i < mImages.Length(); i++) {
int xPos = (i % mColumns) * mTileSize;
int yPos = (i / mColumns) * mTileSize;
nsIntRegion imageRegion =
nsIntRegion(IntRect(IntPoint(xPos,yPos),
mImages[i]->GetSize()));
// a single Image can handle this update request
if (imageRegion.Contains(aRegion)) {
// adjust for tile offset
aRegion.MoveBy(-xPos, -yPos);
// forward the actual call
RefPtr<gfx::DrawTarget> drawTarget = mImages[i]->BeginUpdate(aRegion);
// caller expects container space
aRegion.MoveBy(xPos, yPos);
// we don't have a temp surface
mUpdateDrawTarget = nullptr;
// remember which image to EndUpdate
mCurrentImage = i;
return drawTarget.get();
}
}
// Get the real updated region, taking into account the capabilities of
// each TextureImage tile
GetUpdateRegion(aRegion);
mUpdateRegion = aRegion;
bounds = aRegion.GetBounds();
// update covers multiple Images - create a temp surface to paint in
gfx::SurfaceFormat format =
(GetContentType() == gfxContentType::COLOR) ?
gfx::SurfaceFormat::B8G8R8X8: gfx::SurfaceFormat::B8G8R8A8;
mUpdateDrawTarget = gfx::Factory::CreateDrawTarget(gfx::BackendType::CAIRO,
bounds.Size(),
format);
return mUpdateDrawTarget;;
}
void AuthDataBlk::Dump( std::ostream &os ) const
{
// Output buf and data length
os << "(AuthDataBlock " << endl;
os << " ContentType=" << (long)GetContentType();
os << " UserId=" << mUserId << endl;
for (AuthCertificateBase::AccessList::const_iterator itr = mAccessList.begin(); itr != mAccessList.end(); ++itr)
os << " CommunityId=" << itr->mCommunityId << " TrustLevel=" << itr->mTrustLevel << endl;
os << " PublicKey=" << mPubKey << endl << ')';
}
bool CertificateDataBlock::Serialize( WONCommon::RawBuffer &theRawBuf ) const
{
unsigned short aDataTag = GetContentType();
theRawBuf.append(reinterpret_cast<const unsigned char*>(&aDataTag), sizeof(aDataTag));
unsigned short aDataLength = ComputeSize();
theRawBuf.append(reinterpret_cast<const unsigned char*>(&aDataLength), sizeof(aDataLength));
return true;
}
void QtCodeToHtmlMainDialog::on_button_convert_clicked()
{
if (ui->tab_source->currentIndex() == 0)
{
//Convert code snippet
const std::string source
= std::string(std::tmpnam(0))
+ (GetContentType() == c2h::ContentType::cpp ? ".cpp" : ".txt");
{
const std::vector<std::string> v = EditToVector(ui->edit_source_snippet);
std::ofstream f(source.c_str());
std::copy(v.begin(),v.end(),std::ostream_iterator<std::string>(f,"\n"));
}
c2h::Dialog d(
GetPageType(),
source,
GetContentType(),
GetTechInfo());
const std::vector<std::string> v = d.ToHtml();
Display(v);
boost::filesystem::remove(source);
}
else
{
//Convert file or folder
const std::string source = ui->edit_source->text().toStdString();
if (!boost::filesystem::exists(source))
{
ui->button_convert->setText("Source (file or folder) does not exist");
ui->button_convert->setEnabled(false);
return;
}
c2h::Dialog d(
GetPageType(),
source,
GetContentType(),
GetTechInfo());
const std::vector<std::string> v = d.ToHtml();
Display(v);
}
//Make a screenshot
// QPixmap::grabWidget(this).save("ToolCodeToHtmlMainDialog.png");
}
NS_IMETHODIMP
WebBrowserPersistLocalDocument::GetContentType(nsACString& aContentType)
{
nsAutoString utf16Type;
nsresult rv;
rv = mDocument->GetContentType(utf16Type);
NS_ENSURE_SUCCESS(rv, rv);
aContentType = NS_ConvertUTF16toUTF8(utf16Type);
return NS_OK;
}
LPMIMEBLOCK CMime::AddFile( LPCTSTR pFile, LPBYTE buf, DWORD size, DWORD flags )
{_STT();
// Allocate memory
LPMIMEBLOCK node = new MIMEBLOCK;
if ( node == NULL ) return NULL;
ZeroMimeBlock( node );
// Get the file name
if ( pFile != NULL ) { strcpy_sz( node->fname, pFile ); }
// Get MIME type
GetContentType( node->fname, node->ctype );
// Create Content-Type string
char typestr[ MIME_STRSIZE ];
wsprintf( typestr, "%s;\r\n\tname=\"%s\"", node->ctype, node->fname );
// Save header information
node->var.AddVar( "Content-Type", typestr );
node->var.AddVar( "Content-Transfer-Encoding", "base64" );
if ( ( flags & MBF1_ATTACHMENT ) != 0 )
{
char disp[ MIME_STRSIZE ];
wsprintf( disp, "attachment;\r\n\tfilename=\"%s\"", node->fname );
node->var.AddVar( "Content-Disposition", disp );
} // end if
// Save flags
node->f1 = flags;
node->f1 |= MBF1_DECODED;
// Use base64 encoding
node->encode = MBEN_BASE64;
// Any data?
if ( size > 0 )
{
// Allocate memory
node->pdata = new char[ size + 1 ];
if ( node->pdata == NULL ) { delete node; return FALSE; }
// Copy the data
memcpy( node->pdata, buf, size );
node->dsize = size;
// NULL terminate (just in case)
( (LPBYTE)node->pdata )[ size ] = 0;
} // end if
return AddBlock( node );
}
// Return the media type represented by Content-Type field (see RFC 2046)
MimeHeader::MediaType MimeHeader::GetMediaType() const
{
const char* pszType = GetContentType();
if (!pszType)
pszType = "text";
int nIndex = 0;
while (m_TypeTable[nIndex] != NULL &&
::_memicmp(pszType, m_TypeTable[nIndex], ::strlen(m_TypeTable[nIndex])) != 0)
nIndex++;
return (MediaType) nIndex;
}
void WtDialog::on_button_convert_clicked()
{
if (ui.m_stack->currentIndex() == 0)
{
const std::string source
= std::string(std::tmpnam(0))
+ (GetContentType() == c2h::ContentType::cpp ? ".cpp" : ".txt");
{
const std::vector<std::string> v = AreaToVector(ui.m_area_snippet);
std::ofstream f(source.c_str());
std::copy(v.begin(),v.end(),std::ostream_iterator<std::string>(f,"\n"));
}
c2h::Dialog d(
GetPageType(),
source,
GetContentType(),
GetTechInfo());
const std::vector<std::string> v = d.ToHtml();
Display(v);
boost::filesystem::remove(source);
}
else
{
//assert(ui->tab_source->currentWidget() == ui->tab_source_snippet);
const std::string source = ui.m_edit_source->text().toUTF8();
if (!boost::filesystem::exists(source))
{
ui.m_button_convert->setText("Source (file or folder) does not exist");
return;
}
c2h::Dialog d(
GetPageType(),
source,
GetContentType(),
GetTechInfo());
const std::vector<std::string> v = d.ToHtml();
Display(v);
}
}
nsresult
ChannelMediaResource::RecreateChannel()
{
nsLoadFlags loadFlags =
nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE_IF_BUSY |
(mLoadInBackground ? nsIRequest::LOAD_BACKGROUND : 0);
MediaDecoderOwner* owner = mDecoder->GetMediaOwner();
if (!owner) {
// The decoder is being shut down, so don't bother opening a new channel
return NS_OK;
}
dom::HTMLMediaElement* element = owner->GetMediaElement();
if (!element) {
// The decoder is being shut down, so don't bother opening a new channel
return NS_OK;
}
nsCOMPtr<nsILoadGroup> loadGroup = element->GetDocumentLoadGroup();
NS_ENSURE_TRUE(loadGroup, NS_ERROR_NULL_POINTER);
nsCOMPtr<nsIChannel> channel;
nsresult rv = NS_NewChannel(getter_AddRefs(channel),
mURI,
nullptr,
loadGroup,
nullptr,
loadFlags);
mChannel = new nsMainThreadPtrHolder<nsIChannel>(channel);
// We have cached the Content-Type, which should not change. Give a hint to
// the channel to avoid a sniffing failure, which would be expected because we
// are probably seeking in the middle of the bitstream, and sniffing relies
// on the presence of a magic number at the beginning of the stream.
NS_ASSERTION(!GetContentType().IsEmpty(),
"When recreating a channel, we should know the Content-Type.");
mChannel->SetContentType(GetContentType());
return rv;
}
int CheckIfFileIsFlash(const char * filename)
{
// if (AmmServer_FileExists(filename))
{
char contentType[512];
GetContentType(filename,contentType,512);
if ( GetExtentionType(contentType)==FLASH)
{
//Todo also check internals of files ( file magic number headers etc )
return 1;
}
}
return 0;
}
// retrieves file and sends it to client
bool GetFile(int conn, const char *fname)
{
if (!fname) return false;
// open file
FILE *fp = fopen(fname,"rb");
if (!fp) return false;
// get file size
fseek(fp,0,SEEK_END);
const int size = ftell(fp);
fseek(fp,0,SEEK_SET);
// read data
char *data = NULL;
if (size > 0) {
data = new char[size];
fread(data,size,1,fp);
}
// close file
fclose( fp );
// raw head by default
const char *ctype = GetContentType( fname );
const char *fmt = "HTTP/1.1 200 OK\r\n"
"Content-Length: %i\r\n"
"Content-Type: %s\r\n"
//"Connection: close\r\n"
"\r\n";
// write header to client socket
char head[256];
sprintf(head, fmt, size, ctype);
write(conn, head, strlen(head) );
// write data to client socket
if (data) {
write(conn, data, size);
}
// deallocate
if (data) {
delete [] data;
}
// success
return true;
}
int CHttpString::GetCharset(){
CString strContentType = GetContentType();
int nLeft = strContentType.Find("charset=");
nLeft = nLeft + 8;
CString strChatset = "";
strChatset = strContentType.Mid(nLeft,strContentType.GetLength() - nLeft);
strChatset.Replace(" ","");
strChatset.Replace("\t","");
strChatset.Replace("\r","");
strChatset.Replace("\n","");
if(strChatset == "ANSI") return 1;
else if(strChatset == "UTF-8") return 2;
else return -1;
}
// initialize the content of this body part with a mail message
bool MimeBody::SetMessage(const MimeBody* pMM)
{
ASSERT(pMM != NULL);
int nSize = pMM->GetLength();
if (!AllocateBuffer(nSize+4))
return false;
pMM->Store(m_pbText);
const char* pszType = GetContentType();
if (!pszType || ::_memicmp(pszType, "message", 7) != 0)
SetContentType("message/rfc822", "");
return true;
}
// get the top-level media type
string MimeHeader::GetMainType() const
{
string strType;
const char* pszType = GetContentType();
if (pszType != NULL)
{
const char* pszSlash = ::strchr(pszType, '/');
if (pszSlash != NULL)
strType.assign(pszType, pszSlash-pszType);
else
strType = pszType;
}
else
strType = "text";
return strType;
}
/*
GetIcyData()
*/
void CIcy::GetIcyData(ICYDATA* pIcyData)
{
memset(pIcyData,'\0',sizeof(ICYDATA));
if(m_nResponse==ICY_CODE_OK)
{
strcpyn(pIcyData->station,GetStationName(),ICY_MAX_STATION+1);
strcpyn(pIcyData->genre,GetGenre(),ICY_MAX_GENRE+1);
strcpyn(pIcyData->url,GetUrl(),ICY_MAX_URL+1);
strcpyn(pIcyData->contenttype,GetContentType(),ICY_MAX_CONTENT+1);
pIcyData->metaint = GetMetaInterval();
pIcyData->bitrate = GetBitRate();
strcpyn(pIcyData->notice,GetNotice(),ICY_MAX_NOTICE+1);
strcpyn(pIcyData->noticeinfo,GetNoticeInfo(),ICY_MAX_NOTICE+1);
pIcyData->code = m_nResponse;
}
}
// initialize the content of this body part with a mail message
bool CMimeBody::SetMessage(const CMimeMessage* pMM)
{
ASSERT(pMM != NULL);
int nSize = pMM->GetLength();
if (!AllocateBuffer(nSize+4))
return false;
nSize = pMM->Store((char*)m_pbText, nSize);
m_pbText[nSize] = 0;
m_nTextSize = nSize;
const char* pszType = GetContentType();
if (!pszType || ::memicmp(pszType, "message", 7) != 0)
SetContentType("message/rfc822");
//SetTransferEncoding(CMimeConst::EncodingBinary()); // in case the default 7bit cause folding
return true;
}
void CPlayerPlaylistBar::ParsePlayList(CAtlList<CString>& fns, CAtlList<CString>* subs)
{
if (fns.IsEmpty()) {
return;
}
const CAppSettings& s = AfxGetAppSettings();
ResolveLinkFiles(fns);
CAtlList<CString> sl;
if (SearchFiles(fns.GetHead(), sl)) {
if (sl.GetCount() > 1) {
subs = NULL;
}
POSITION pos = sl.GetHeadPosition();
while (pos) {
ParsePlayList(sl.GetNext(pos), subs);
}
return;
}
CAtlList<CString> redir;
CStringA ct = GetContentType(fns.GetHead(), &redir);
if (!redir.IsEmpty()) {
POSITION pos = redir.GetHeadPosition();
while (pos) {
ParsePlayList(sl.GetNext(pos), subs);
}
return;
}
if (ct == "application/x-mpc-playlist") {
ParseMPCPlayList(fns.GetHead());
return;
} else {
#if INTERNAL_SOURCEFILTER_MPEG
if (ct == "application/x-bdmv-playlist" && s.SrcFilters[SRC_MPEG]) {
ParseBDMVPlayList(fns.GetHead());
return;
}
#endif
}
AddItem(fns, subs);
}
int GetExtensionImage(char * filename, char * theimagepath,unsigned int theimagepath_length)
{
//fprintf(stderr,"GetExtensionImage for %s \n",filename);
GetContentType(filename,theimagepath,theimagepath_length);
//fprintf(stderr,"GetExtentionType for %s \n",filename);
int res=GetExtentionType(theimagepath);
//fprintf(stderr,"yields %u\n",res);
switch (res)
{
case TEXT : snprintf(theimagepath,theimagepath_length,"doc.gif"); break;
case IMAGE : snprintf(theimagepath,theimagepath_length,"img.gif"); break;
case VIDEO : snprintf(theimagepath,theimagepath_length,"vid.gif"); break;
case AUDIO : snprintf(theimagepath,theimagepath_length,"mus.gif"); break;
case EXECUTABLE : snprintf(theimagepath,theimagepath_length,"exe.gif"); break;
default : snprintf(theimagepath,theimagepath_length,"dir.gif"); break;
}
if ( res == NO_FILETYPE ) { return 0; }
return 1;
}
already_AddRefed<gfxASurface>
gfxWindowsSurface::CreateSimilarSurface(gfxContentType aContent,
const gfxIntSize& aSize)
{
if (!mSurface || !mSurfaceValid) {
return nullptr;
}
cairo_surface_t *surface;
if (!mForPrinting && GetContentType() == gfxContentType::COLOR_ALPHA) {
// When creating a similar surface to a transparent surface, ensure
// the new surface uses a DIB. cairo_surface_create_similar won't
// use a DIB for a gfxContentType::COLOR surface if this surface doesn't
// have a DIB (e.g. if we're a transparent window surface). But
// we need a DIB to perform well if the new surface is composited into
// a surface that's the result of create_similar(gfxContentType::COLOR_ALPHA)
// (e.g. a backbuffer for the window) --- that new surface *would*
// have a DIB.
surface =
cairo_win32_surface_create_with_dib((cairo_format_t)(int)gfxPlatform::GetPlatform()->OptimalFormatForContent(aContent),
aSize.width, aSize.height);
} else {
surface =
cairo_surface_create_similar(mSurface, (cairo_content_t)(int)aContent,
aSize.width, aSize.height);
}
if (cairo_surface_status(surface)) {
cairo_surface_destroy(surface);
return nullptr;
}
nsRefPtr<gfxASurface> result = Wrap(surface);
if (mForPrinting) {
MOZ_ASSERT(result->GetType() == gfxSurfaceType::Recording);
gfxUnknownSurface *unknown = static_cast<gfxUnknownSurface*>(result.get());
unknown->SetSize(aSize);
}
cairo_surface_destroy(surface);
return result.forget();
}
already_AddRefed<gfxASurface>
gfxWindowsSurface::CreateSimilarSurface(gfxContentType aContent,
const mozilla::gfx::IntSize& aSize)
{
if (!mSurface || !mSurfaceValid) {
return nullptr;
}
cairo_surface_t *surface;
if (!mForPrinting && GetContentType() == gfxContentType::COLOR_ALPHA) {
// When creating a similar surface to a transparent surface, ensure
// the new surface uses a DIB. cairo_surface_create_similar won't
// use a DIB for a gfxContentType::COLOR surface if this surface doesn't
// have a DIB (e.g. if we're a transparent window surface). But
// we need a DIB to perform well if the new surface is composited into
// a surface that's the result of create_similar(gfxContentType::COLOR_ALPHA)
// (e.g. a backbuffer for the window) --- that new surface *would*
// have a DIB.
gfxImageFormat gformat =
gfxPlatform::GetPlatform()->OptimalFormatForContent(aContent);
cairo_format_t cformat = gfxImageFormatToCairoFormat(gformat);
surface = cairo_win32_surface_create_with_dib(cformat, aSize.width,
aSize.height);
} else {
surface =
cairo_surface_create_similar(mSurface, (cairo_content_t)(int)aContent,
aSize.width, aSize.height);
}
if (cairo_surface_status(surface)) {
cairo_surface_destroy(surface);
return nullptr;
}
RefPtr<gfxASurface> result = Wrap(surface, aSize);
cairo_surface_destroy(surface);
return result.forget();
}
already_AddRefed<MediaResource> ChannelMediaResource::CloneData(MediaDecoder* aDecoder)
{
NS_ASSERTION(NS_IsMainThread(), "Only call on main thread");
NS_ASSERTION(mCacheStream.IsAvailableForSharing(), "Stream can't be cloned");
nsRefPtr<ChannelMediaResource> resource =
new ChannelMediaResource(aDecoder,
nullptr,
mURI,
GetContentType());
if (resource) {
// Initially the clone is treated as suspended by the cache, because
// we don't have a channel. If the cache needs to read data from the clone
// it will call CacheClientResume (or CacheClientSeek with aResume true)
// which will recreate the channel. This way, if all of the media data
// is already in the cache we don't create an unnecessary HTTP channel
// and perform a useless HTTP transaction.
resource->mSuspendCount = 1;
resource->mCacheStream.InitAsClone(&mCacheStream);
resource->mChannelStatistics = new MediaChannelStatistics(mChannelStatistics);
resource->mChannelStatistics->Stop();
}
return resource.forget();
}
already_AddRefed<gfxASurface>
gfxWindowsSurface::CreateSimilarSurface(gfxContentType aContent,
const gfxIntSize& aSize)
{
if (!mSurface || !mSurfaceValid) {
return nsnull;
}
cairo_surface_t *surface;
if (GetContentType() == CONTENT_COLOR_ALPHA) {
// When creating a similar surface to a transparent surface, ensure
// the new surface uses a DIB. cairo_surface_create_similar won't
// use a DIB for a CONTENT_COLOR surface if this surface doesn't
// have a DIB (e.g. if we're a transparent window surface). But
// we need a DIB to perform well if the new surface is composited into
// a surface that's the result of create_similar(CONTENT_COLOR_ALPHA)
// (e.g. a backbuffer for the window) --- that new surface *would*
// have a DIB.
surface =
cairo_win32_surface_create_with_dib(cairo_format_t(gfxASurface::FormatFromContent(aContent)),
aSize.width, aSize.height);
} else {
surface =
cairo_surface_create_similar(mSurface, cairo_content_t(aContent),
aSize.width, aSize.height);
}
if (cairo_surface_status(surface)) {
cairo_surface_destroy(surface);
return nsnull;
}
nsRefPtr<gfxASurface> result = Wrap(surface);
cairo_surface_destroy(surface);
return result.forget();
}
STDMETHODIMP WBPassthruSink::BeginningTransaction(LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR* pszAdditionalHeaders)
{
if (!szURL)
{
return E_POINTER;
}
std::wstring src = szURL;
UnescapeUrl(src);
DEBUG_GENERAL(src);
std::string acceptHeader = ExtractHttpAcceptHeader(m_spTargetProtocol);
if (pszAdditionalHeaders)
{
*pszAdditionalHeaders = nullptr;
}
CComPtr<IHttpNegotiate> httpNegotiate;
QueryServiceFromClient(&httpNegotiate);
// This fills the pszAdditionalHeaders with more headers. One of which is the Referer header, which we need.
// There doesn't seem to be any other way to get this header before the request has been made.
HRESULT nativeHr = httpNegotiate ? httpNegotiate->BeginningTransaction(szURL, szHeaders, dwReserved, pszAdditionalHeaders) : S_OK;
if (pszAdditionalHeaders && *pszAdditionalHeaders)
{
m_boundDomain = ExtractHttpHeader<std::wstring>(*pszAdditionalHeaders, L"Referer:", L"\n");
}
m_boundDomain = TrimString(m_boundDomain);
m_contentType = GetContentType(ATL::CString(acceptHeader.c_str()), m_boundDomain, src);
CPluginTab* tab = CPluginClass::GetTab(::GetCurrentThreadId());
CPluginClient* client = CPluginClient::GetInstance();
if (tab && client)
{
std::wstring documentUrl = tab->GetDocumentUrl();
// Page is identical to document => don't block
if (documentUrl == src)
{
return nativeHr;
}
else if (CPluginSettings::GetInstance()->IsPluginEnabled() && !client->IsWhitelistedUrl(documentUrl))
{
if (tab->IsFrameCached(src))
{
m_contentType = ContentType::CONTENT_TYPE_SUBDOCUMENT;
}
}
}
if (IsFlashRequest(pszAdditionalHeaders))
{
m_contentType = ContentType::CONTENT_TYPE_OBJECT_SUBREQUEST;
}
if (pszAdditionalHeaders && *pszAdditionalHeaders && IsXmlHttpRequest(*pszAdditionalHeaders))
{
m_contentType = ContentType::CONTENT_TYPE_XMLHTTPREQUEST;
}
if (client->ShouldBlock(szURL, m_contentType, m_boundDomain, /*debug flag but must be set*/true))
{
// NOTE: Feeding custom HTML to Flash, instead of original object subrequest
// doesn't have much sense. It also can manifest in unwanted result
// like video being blocked (See https://issues.adblockplus.org/ticket/1669)
// So we report blocked object subrequests as failed, not just empty HTML.
m_isCustomResponse = m_contentType != ContentType::CONTENT_TYPE_OBJECT_SUBREQUEST;
return E_ABORT;
}
return nativeHr;
}
// CertificateDataBlock::Compare
// Compares two CertificateDataBlock objects.
// This function should be called from the base class Compare.
//
int CertificateDataBlock::Compare(const CertificateDataBlock& theDataR) const
{
return ( GetContentType() - theDataR.GetContentType() );
}
