bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Update to Chromium revision a106f0ab (#464641)

Browse Source 
- Remove CefWindowInfo.transparent_painting_enabled. Set
  CefBrowserSettings.background_color to an opaque or transparent
  value instead.
This commit is contained in:
Marshall Greenblatt
2017-04-20 15:28:17 -04:00
parent 2f6475c0d8
commit 3f71138d64
151 changed files with 2756 additions and 2295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
libcef/common/request_impl.cc
View File

@@ -99,20 +99,20 @@ net::URLRequest::ReferrerPolicy GetURLRequestReferrerPolicy(
net::URLRequest::ReferrerPolicy net_referrer_policy =
net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
switch (static_cast<blink::WebReferrerPolicy>(policy)) {
case blink::WebReferrerPolicyAlways:
case blink::WebReferrerPolicyNever:
case blink::WebReferrerPolicyOrigin:
case blink::kWebReferrerPolicyAlways:
case blink::kWebReferrerPolicyNever:
case blink::kWebReferrerPolicyOrigin:
net_referrer_policy = net::URLRequest::NEVER_CLEAR_REFERRER;
break;
case blink::WebReferrerPolicyNoReferrerWhenDowngrade:
case blink::kWebReferrerPolicyNoReferrerWhenDowngrade:
net_referrer_policy =
net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
break;
case blink::WebReferrerPolicyOriginWhenCrossOrigin:
case blink::kWebReferrerPolicyOriginWhenCrossOrigin:
net_referrer_policy =
net::URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN;
break;
case blink::WebReferrerPolicyDefault:
case blink::kWebReferrerPolicyDefault:
default:
net_referrer_policy =
command_line->HasSwitch(switches::kReducedReferrerGranularity)
@@ -138,9 +138,9 @@ std::string GetURLRequestReferrer(const GURL& referrer_url) {
blink::WebString FilePathStringToWebString(
const base::FilePath::StringType& str) {
#if defined(OS_POSIX)
return blink::WebString::fromUTF8(str);
return blink::WebString::FromUTF8(str);
#elif defined(OS_WIN)
return blink::WebString::fromUTF16(str);
return blink::WebString::FromUTF16(str);
#endif
}
@@ -176,10 +176,10 @@ void GetHeaderMap(const blink::WebURLRequest& request,
referrer_(referrer) {
}
void visitHeader(const blink::WebString& name,
void VisitHeader(const blink::WebString& name,
const blink::WebString& value) override {
const base::string16& nameStr = name.utf16();
const base::string16& valueStr = value.utf16();
const base::string16& nameStr = name.Utf16();
const base::string16& valueStr = value.Utf16();
if (base::LowerCaseEqualsASCII(nameStr, kReferrerLowerCase))
*referrer_ = GURL(valueStr);
else
@@ -192,7 +192,7 @@ void GetHeaderMap(const blink::WebURLRequest& request,
};
HeaderVisitor visitor(&map, &referrer);
request.visitHTTPHeaderFields(&visitor);
request.VisitHTTPHeaderFields(&visitor);
}
// Read |source| into |map|.
@@ -215,8 +215,8 @@ void SetHeaderMap(const CefRequest::HeaderMap& map,
blink::WebURLRequest& request) {
CefRequest::HeaderMap::const_iterator it = map.begin();
for (; it != map.end(); ++it) {
request.setHTTPHeaderField(blink::WebString::fromUTF16(it->first),
blink::WebString::fromUTF16(it->second));
request.SetHTTPHeaderField(blink::WebString::FromUTF16(it->first),
blink::WebString::FromUTF16(it->second));
}
}
@@ -494,8 +494,8 @@ void CefRequestImpl::Get(net::URLRequest* request, bool changed_only) const {
if (ShouldSet(kChangedPostData, changed_only)) {
if (postdata_.get()) {
request->set_upload(base::WrapUnique(
static_cast<CefPostDataImpl*>(postdata_.get())->Get()));
request->set_upload(
static_cast<CefPostDataImpl*>(postdata_.get())->Get());
} else if (request->get_upload()) {
request->set_upload(std::unique_ptr<net::UploadDataStream>());
}
@@ -530,33 +530,33 @@ void CefRequestImpl::Set(
}
void CefRequestImpl::Set(const blink::WebURLRequest& request) {
DCHECK(!request.isNull());
DCHECK(!request.IsNull());
base::AutoLock lock_scope(lock_);
CHECK_READONLY_RETURN_VOID();
Reset();
url_ = request.url();
method_ = request.httpMethod().utf8();
url_ = request.Url();
method_ = request.HttpMethod().Utf8();
::GetHeaderMap(request, headermap_, referrer_url_);
referrer_policy_ =
static_cast<cef_referrer_policy_t>(request.getReferrerPolicy());
static_cast<cef_referrer_policy_t>(request.GetReferrerPolicy());
const blink::WebHTTPBody& body = request.httpBody();
if (!body.isNull()) {
const blink::WebHTTPBody& body = request.HttpBody();
if (!body.IsNull()) {
postdata_ = new CefPostDataImpl();
static_cast<CefPostDataImpl*>(postdata_.get())->Set(body);
}
first_party_for_cookies_ = request.firstPartyForCookies();
first_party_for_cookies_ = request.FirstPartyForCookies();
if (request.getCachePolicy() == blink::WebCachePolicy::BypassingCache)
if (request.GetCachePolicy() == blink::WebCachePolicy::kBypassingCache)
flags_ |= UR_FLAG_SKIP_CACHE;
if (request.allowStoredCredentials())
if (request.AllowStoredCredentials())
flags_ |= UR_FLAG_ALLOW_CACHED_CREDENTIALS;
if (request.reportUploadProgress())
if (request.ReportUploadProgress())
flags_ |= UR_FLAG_REPORT_UPLOAD_PROGRESS;
}
@@ -564,18 +564,18 @@ void CefRequestImpl::Get(blink::WebURLRequest& request,
int64& upload_data_size) const {
base::AutoLock lock_scope(lock_);
request.setRequestContext(blink::WebURLRequest::RequestContextInternal);
request.setURL(url_);
request.setHTTPMethod(blink::WebString::fromUTF8(method_));
request.SetRequestContext(blink::WebURLRequest::kRequestContextInternal);
request.SetURL(url_);
request.SetHTTPMethod(blink::WebString::FromUTF8(method_));
if (!referrer_url_.is_empty()) {
const blink::WebString& referrer =
blink::WebSecurityPolicy::generateReferrerHeader(
blink::WebSecurityPolicy::GenerateReferrerHeader(
static_cast<blink::WebReferrerPolicy>(referrer_policy_),
url_,
blink::WebString::fromUTF8(referrer_url_.spec()));
if (!referrer.isEmpty()) {
request.setHTTPReferrer(
blink::WebString::FromUTF8(referrer_url_.spec()));
if (!referrer.IsEmpty()) {
request.SetHTTPReferrer(
referrer,
static_cast<blink::WebReferrerPolicy>(referrer_policy_));
}
@@ -583,9 +583,9 @@ void CefRequestImpl::Get(blink::WebURLRequest& request,
if (postdata_.get()) {
blink::WebHTTPBody body;
body.initialize();
body.Initialize();
static_cast<CefPostDataImpl*>(postdata_.get())->Get(body);
request.setHTTPBody(body);
request.SetHTTPBody(body);
if (flags_ & UR_FLAG_REPORT_UPLOAD_PROGRESS) {
// Attempt to determine the upload data size.
@@ -602,33 +602,33 @@ void CefRequestImpl::Get(blink::WebURLRequest& request,
::SetHeaderMap(headermap_, request);
if (!first_party_for_cookies_.is_empty())
request.setFirstPartyForCookies(first_party_for_cookies_);
request.SetFirstPartyForCookies(first_party_for_cookies_);
request.setCachePolicy((flags_ & UR_FLAG_SKIP_CACHE) ?
blink::WebCachePolicy::BypassingCache :
blink::WebCachePolicy::UseProtocolCachePolicy);
request.SetCachePolicy((flags_ & UR_FLAG_SKIP_CACHE) ?
blink::WebCachePolicy::kBypassingCache :
blink::WebCachePolicy::kUseProtocolCachePolicy);
SETBOOLFLAG(request, flags_, setAllowStoredCredentials,
SETBOOLFLAG(request, flags_, SetAllowStoredCredentials,
UR_FLAG_ALLOW_CACHED_CREDENTIALS);
SETBOOLFLAG(request, flags_, setReportUploadProgress,
SETBOOLFLAG(request, flags_, SetReportUploadProgress,
UR_FLAG_REPORT_UPLOAD_PROGRESS);
}
// static
void CefRequestImpl::Get(const CefMsg_LoadRequest_Params& params,
blink::WebURLRequest& request) {
request.setURL(params.url);
request.SetURL(params.url);
if (!params.method.empty())
request.setHTTPMethod(blink::WebString::fromASCII(params.method));
request.SetHTTPMethod(blink::WebString::FromASCII(params.method));
if (params.referrer.is_valid()) {
const blink::WebString& referrer =
blink::WebSecurityPolicy::generateReferrerHeader(
blink::WebSecurityPolicy::GenerateReferrerHeader(
static_cast<blink::WebReferrerPolicy>(params.referrer_policy),
params.url,
blink::WebString::fromUTF8(params.referrer.spec()));
if (!referrer.isEmpty()) {
request.setHTTPReferrer(
blink::WebString::FromUTF8(params.referrer.spec()));
if (!referrer.IsEmpty()) {
request.SetHTTPReferrer(
referrer,
static_cast<blink::WebReferrerPolicy>(params.referrer_policy));
}
@@ -638,59 +638,54 @@ void CefRequestImpl::Get(const CefMsg_LoadRequest_Params& params,
for (net::HttpUtil::HeadersIterator i(params.headers.begin(),
params.headers.end(), "\n");
i.GetNext(); ) {
request.addHTTPHeaderField(blink::WebString::fromUTF8(i.name()),
blink::WebString::fromUTF8(i.values()));
request.AddHTTPHeaderField(blink::WebString::FromUTF8(i.name()),
blink::WebString::FromUTF8(i.values()));
}
}
if (params.upload_data.get()) {
const base::string16& method = request.httpMethod().utf16();
const base::string16& method = request.HttpMethod().Utf16();
if (method == base::ASCIIToUTF16("GET") ||
method == base::ASCIIToUTF16("HEAD")) {
request.setHTTPMethod(blink::WebString::fromASCII("POST"));
request.SetHTTPMethod(blink::WebString::FromASCII("POST"));
}
// The comparison performed by httpHeaderField() is case insensitive.
if (request.httpHeaderField(blink::WebString::fromASCII(
if (request.HttpHeaderField(blink::WebString::FromASCII(
net::HttpRequestHeaders::kContentType)).length()== 0) {
request.setHTTPHeaderField(
blink::WebString::fromASCII(net::HttpRequestHeaders::kContentType),
blink::WebString::fromASCII(kApplicationFormURLEncoded));
request.SetHTTPHeaderField(
blink::WebString::FromASCII(net::HttpRequestHeaders::kContentType),
blink::WebString::FromASCII(kApplicationFormURLEncoded));
}
blink::WebHTTPBody body;
body.initialize();
body.Initialize();
const ScopedVector<net::UploadElement>& elements =
params.upload_data->elements();
ScopedVector<net::UploadElement>::const_iterator it =
elements.begin();
for (; it != elements.end(); ++it) {
const net::UploadElement& element = **it;
if (element.type() == net::UploadElement::TYPE_BYTES) {
for (const auto& element : params.upload_data->elements()) {
if (element->type() == net::UploadElement::TYPE_BYTES) {
blink::WebData data;
data.assign(element.bytes(), element.bytes_length());
body.appendData(data);
} else if (element.type() == net::UploadElement::TYPE_FILE) {
body.appendFile(FilePathStringToWebString(element.file_path().value()));
data.Assign(element->bytes(), element->bytes_length());
body.AppendData(data);
} else if (element->type() == net::UploadElement::TYPE_FILE) {
body.AppendFile(FilePathStringToWebString(element->file_path().value()));
} else {
NOTREACHED();
}
}
request.setHTTPBody(body);
request.SetHTTPBody(body);
}
if (params.first_party_for_cookies.is_valid())
request.setFirstPartyForCookies(params.first_party_for_cookies);
request.SetFirstPartyForCookies(params.first_party_for_cookies);
request.setCachePolicy((params.load_flags & UR_FLAG_SKIP_CACHE) ?
blink::WebCachePolicy::BypassingCache :
blink::WebCachePolicy::UseProtocolCachePolicy);
request.SetCachePolicy((params.load_flags & UR_FLAG_SKIP_CACHE) ?
blink::WebCachePolicy::kBypassingCache :
blink::WebCachePolicy::kUseProtocolCachePolicy);
SETBOOLFLAG(request, params.load_flags, setAllowStoredCredentials,
SETBOOLFLAG(request, params.load_flags, SetAllowStoredCredentials,
UR_FLAG_ALLOW_CACHED_CREDENTIALS);
SETBOOLFLAG(request, params.load_flags, setReportUploadProgress,
SETBOOLFLAG(request, params.load_flags, SetReportUploadProgress,
UR_FLAG_REPORT_UPLOAD_PROGRESS);
}
@@ -984,11 +979,9 @@ void CefPostDataImpl::Set(const net::UploadData& data) {
CefRefPtr<CefPostDataElement> postelem;
const ScopedVector<net::UploadElement>& elements = data.elements();
ScopedVector<net::UploadElement>::const_iterator it = elements.begin();
for (; it != elements.end(); ++it) {
for (const auto& element : data.elements()) {
postelem = CefPostDataElement::Create();
static_cast<CefPostDataElementImpl*>(postelem.get())->Set(**it);
static_cast<CefPostDataElementImpl*>(postelem.get())->Set(*element);
AddElement(postelem);
}
}
@@ -1018,27 +1011,28 @@ void CefPostDataImpl::Set(const net::UploadDataStream& data_stream) {
void CefPostDataImpl::Get(net::UploadData& data) const {
base::AutoLock lock_scope(lock_);
ScopedVector<net::UploadElement> data_elements;
ElementVector::const_iterator it = elements_.begin();
for (; it != elements_.end(); ++it) {
net::UploadElement* element = new net::UploadElement();
static_cast<CefPostDataElementImpl*>(it->get())->Get(*element);
data_elements.push_back(element);
net::UploadData::ElementsVector data_elements;
for (const auto& element : elements_) {
std::unique_ptr<net::UploadElement> data_element =
base::MakeUnique<net::UploadElement>();
static_cast<CefPostDataElementImpl*>(element.get())->Get(
*data_element.get());
data_elements.push_back(std::move(data_element));
}
data.swap_elements(&data_elements);
}
net::UploadDataStream* CefPostDataImpl::Get() const {
std::unique_ptr<net::UploadDataStream> CefPostDataImpl::Get() const {
base::AutoLock lock_scope(lock_);
UploadElementReaders element_readers;
ElementVector::const_iterator it = elements_.begin();
for (; it != elements_.end(); ++it) {
element_readers.push_back(base::WrapUnique(
static_cast<CefPostDataElementImpl*>(it->get())->Get()));
for (const auto& element : elements_) {
element_readers.push_back(
static_cast<CefPostDataElementImpl*>(element.get())->Get());
}
return new net::ElementsUploadDataStream(std::move(element_readers), 0);
return base::MakeUnique<net::ElementsUploadDataStream>(
std::move(element_readers), 0);
}
void CefPostDataImpl::Set(const blink::WebHTTPBody& data) {
@@ -1049,9 +1043,9 @@ void CefPostDataImpl::Set(const blink::WebHTTPBody& data) {
CefRefPtr<CefPostDataElement> postelem;
blink::WebHTTPBody::Element element;
size_t size = data.elementCount();
size_t size = data.ElementCount();
for (size_t i = 0; i < size; ++i) {
if (data.elementAt(i, element)) {
if (data.ElementAt(i, element)) {
postelem = CefPostDataElement::Create();
static_cast<CefPostDataElementImpl*>(postelem.get())->Set(element);
AddElement(postelem);
@@ -1066,10 +1060,10 @@ void CefPostDataImpl::Get(blink::WebHTTPBody& data) const {
ElementVector::const_iterator it = elements_.begin();
for (; it != elements_.end(); ++it) {
static_cast<CefPostDataElementImpl*>(it->get())->Get(element);
if (element.type == blink::WebHTTPBody::Element::TypeData) {
data.appendData(element.data);
} else if (element.type == blink::WebHTTPBody::Element::TypeFile) {
data.appendFile(element.filePath);
if (element.type == blink::WebHTTPBody::Element::kTypeData) {
data.AppendData(element.data);
} else if (element.type == blink::WebHTTPBody::Element::kTypeFile) {
data.AppendFile(element.file_path);
} else {
NOTREACHED();
}
@@ -1284,22 +1278,22 @@ void CefPostDataElementImpl::Get(net::UploadElement& element) const {
}
}
net::UploadElementReader* CefPostDataElementImpl::Get() const {
std::unique_ptr<net::UploadElementReader> CefPostDataElementImpl::Get() const {
base::AutoLock lock_scope(lock_);
if (type_ == PDE_TYPE_BYTES) {
net::UploadElement* element = new net::UploadElement();
element->SetToBytes(static_cast<char*>(data_.bytes.bytes),
data_.bytes.size);
return new BytesElementReader(base::WrapUnique(element));
return base::MakeUnique<BytesElementReader>(base::WrapUnique(element));
} else if (type_ == PDE_TYPE_FILE) {
net::UploadElement* element = new net::UploadElement();
base::FilePath path = base::FilePath(CefString(&data_.filename));
element->SetToFilePath(path);
return new FileElementReader(base::WrapUnique(element));
return base::MakeUnique<FileElementReader>(base::WrapUnique(element));
} else {
NOTREACHED();
return NULL;
return nullptr;
}
}
@@ -1309,11 +1303,11 @@ void CefPostDataElementImpl::Set(const blink::WebHTTPBody::Element& element) {
CHECK_READONLY_RETURN_VOID();
}
if (element.type == blink::WebHTTPBody::Element::TypeData) {
if (element.type == blink::WebHTTPBody::Element::kTypeData) {
SetToBytes(element.data.size(),
static_cast<const void*>(element.data.data()));
} else if (element.type == blink::WebHTTPBody::Element::TypeFile) {
SetToFile(element.filePath.utf16());
static_cast<const void*>(element.data.Data()));
} else if (element.type == blink::WebHTTPBody::Element::kTypeFile) {
SetToFile(element.file_path.Utf16());
} else {
NOTREACHED();
}
@@ -1323,13 +1317,13 @@ void CefPostDataElementImpl::Get(blink::WebHTTPBody::Element& element) const {
base::AutoLock lock_scope(lock_);
if (type_ == PDE_TYPE_BYTES) {
element.type = blink::WebHTTPBody::Element::TypeData;
element.data.assign(
element.type = blink::WebHTTPBody::Element::kTypeData;
element.data.Assign(
static_cast<char*>(data_.bytes.bytes), data_.bytes.size);
} else if (type_ == PDE_TYPE_FILE) {
element.type = blink::WebHTTPBody::Element::TypeFile;
element.filePath.assign(
blink::WebString::fromUTF16(CefString(&data_.filename)));
element.type = blink::WebHTTPBody::Element::kTypeFile;
element.file_path.Assign(
blink::WebString::FromUTF16(CefString(&data_.filename)));
} else {
NOTREACHED();
}