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 3a87aecc (#433059)

Browse Source
This commit is contained in:
Marshall Greenblatt
2016-11-23 15:54:29 -05:00
parent c6881fe145
commit 12aeeb13f7
126 changed files with 1643 additions and 1436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
BUILD.gn
View File

@ -99,8 +99,12 @@ import("//build/config/locales.gni")
import("//build/config/sanitizers/sanitizers.gni")
import("//build/config/ui.gni")
import("//cef/cef_repack_locales.gni")
import("//chrome/common/features.gni")
import("//extensions/features/features.gni")
import("//media/media_options.gni")
import("//mojo/public/tools/bindings/mojom.gni")
import("//ppapi/features/features.gni")
import("//printing/features/features.gni")
import("//third_party/icu/config.gni")
import("//third_party/widevine/cdm/widevine.gni")
import("//tools/grit/repack.gni")
@ -318,10 +322,10 @@ static_library("libcef_static") {
"libcef/browser/net/network_delegate.h",
"libcef/browser/net/resource_request_job.cc",
"libcef/browser/net/resource_request_job.h",
"libcef/browser/net/response_filter_wrapper.cc",
"libcef/browser/net/response_filter_wrapper.h",
"libcef/browser/net/scheme_handler.cc",
"libcef/browser/net/scheme_handler.h",
"libcef/browser/net/source_stream.cc",
"libcef/browser/net/source_stream.h",
"libcef/browser/net/url_request_context.cc",
"libcef/browser/net/url_request_context.h",
"libcef/browser/net/url_request_context_getter.h",
@ -608,12 +612,13 @@ static_library("libcef_static") {
"//content/public/renderer",
"//content/public/utility",
"//crypto",
"//device/core",
"//device/base",
"//device/geolocation",
"//device/hid",
"//extensions/browser",
"//extensions/browser/api:api_registration",
"//extensions/common/api",
"//extensions/common/api:api_registration",
"//extensions/features",
"//extensions/renderer",
"//extensions/utility",
"//gpu",
@ -624,6 +629,8 @@ static_library("libcef_static") {
"//net:net_browser_services",
"//net:net_with_v8",
"//pdf",
"//ppapi/features",
"//printing/features",
"//skia",
"//storage/browser",
"//third_party/brotli",
@ -632,7 +639,7 @@ static_library("libcef_static") {
"//third_party/leveldatabase",
"//third_party/libxml",
"//third_party/WebKit/public:blink",
"//third_party/widevine/cdm:version_h",
"//third_party/widevine/cdm:headers",
"//third_party/icu",
"//third_party/zlib:minizip",
"//ui/base",
@ -672,8 +679,10 @@ static_library("libcef_static") {
"libcef/browser/osr/browser_platform_delegate_osr_win.cc",
"libcef/browser/osr/browser_platform_delegate_osr_win.h",
"libcef/browser/osr/render_widget_host_view_osr_win.cc",
"libcef/utility/printing_handler.cc",
"libcef/utility/printing_handler.h",
# Part of //chrome/utility.
"//chrome/utility/printing_handler.cc",
"//chrome/utility/printing_handler.h",
]
deps += [

2
CHROMIUM_BUILD_COMPATIBILITY.txt
View File

@ -7,5 +7,5 @@
# https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding
{
'chromium_checkout': '614d31daee2f61b0180df403a8ad43f20b9f6dd7',
'chromium_checkout': '3a87aecc31cd1ffe751dd72c04e5a96a1fc8108a',
}

45
include/capi/cef_response_filter_capi.h
View File

@ -62,22 +62,35 @@ typedef struct _cef_response_filter_t {
int (CEF_CALLBACK *init_filter)(struct _cef_response_filter_t* self);
///
// Called to filter a chunk of data. |data_in| is the input buffer containing
// |data_in_size| bytes of pre-filter data (|data_in| will be NULL if
// |data_in_size| is zero). |data_out| is the output buffer that can accept up
// to |data_out_size| bytes of filtered output data. Set |data_in_read| to the
// number of bytes that were read from |data_in|. Set |data_out_written| to
// the number of bytes that were written into |data_out|. If some or all of
// the pre-filter data was read successfully but more data is needed in order
// to continue filtering (filtered output is pending) return
// RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was
// read successfully and all available filtered output has been written return
// RESPONSE_FILTER_DONE. If an error occurs during filtering return
// RESPONSE_FILTER_ERROR. This function will be called repeatedly until there
// is no more data to filter (resource response is complete), |data_in_read|
// matches |data_in_size| (all available pre-filter bytes have been read), and
// the function returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not
// keep a reference to the buffers passed to this function.
// Called to filter a chunk of data. Expected usage is as follows:
//
// A. Read input data from |data_in| and set |data_in_read| to the number of
// bytes that were read up to a maximum of |data_in_size|. |data_in| will
// be NULL if |data_in_size| is zero.
// B. Write filtered output data to |data_out| and set |data_out_written| to
// the number of bytes that were written up to a maximum of
// |data_out_size|. If no output data was written then all data must be
// read from |data_in| (user must set |data_in_read| = |data_in_size|).
// C. Return RESPONSE_FILTER_DONE if all output data was written or
// RESPONSE_FILTER_NEED_MORE_DATA if output data is still pending.
//
// This function will be called repeatedly until the input buffer has been
// fully read (user sets |data_in_read| = |data_in_size|) and there is no more
// input data to filter (the resource response is complete). This function may
// then be called an additional time with an NULL input buffer if the user
// filled the output buffer (set |data_out_written| = |data_out_size|) and
// returned RESPONSE_FILTER_NEED_MORE_DATA to indicate that output data is
// still pending.
//
// Calls to this function will stop when one of the following conditions is
// met:
//
// A. There is no more input data to filter (the resource response is
// complete) and the user sets |data_out_written| = 0 or returns
// RESPONSE_FILTER_DONE to indicate that all data has been written, or;
// B. The user returns RESPONSE_FILTER_ERROR to indicate an error.
//
// Do not keep a reference to the buffers passed to this function.
///
cef_response_filter_status_t (CEF_CALLBACK *filter)(
struct _cef_response_filter_t* self, void* data_in, size_t data_in_size,

44
include/cef_response_filter.h
View File

@ -57,22 +57,34 @@ class CefResponseFilter : public virtual CefBase {
virtual bool InitFilter() =0;
///
// Called to filter a chunk of data. |data_in| is the input buffer containing
// |data_in_size| bytes of pre-filter data (|data_in| will be NULL if
// |data_in_size| is zero). |data_out| is the output buffer that can accept up
// to |data_out_size| bytes of filtered output data. Set |data_in_read| to the
// number of bytes that were read from |data_in|. Set |data_out_written| to
// the number of bytes that were written into |data_out|. If some or all of
// the pre-filter data was read successfully but more data is needed in order
// to continue filtering (filtered output is pending) return
// RESPONSE_FILTER_NEED_MORE_DATA. If some or all of the pre-filter data was
// read successfully and all available filtered output has been written return
// RESPONSE_FILTER_DONE. If an error occurs during filtering return
// RESPONSE_FILTER_ERROR. This method will be called repeatedly until there is
// no more data to filter (resource response is complete), |data_in_read|
// matches |data_in_size| (all available pre-filter bytes have been read), and
// the method returns RESPONSE_FILTER_DONE or RESPONSE_FILTER_ERROR. Do not
// keep a reference to the buffers passed to this method.
// Called to filter a chunk of data. Expected usage is as follows:
//
// A. Read input data from |data_in| and set |data_in_read| to the number of
// bytes that were read up to a maximum of |data_in_size|. |data_in| will
// be NULL if |data_in_size| is zero.
// B. Write filtered output data to |data_out| and set |data_out_written| to
// the number of bytes that were written up to a maximum of
// |data_out_size|. If no output data was written then all data must be
// read from |data_in| (user must set |data_in_read| = |data_in_size|).
// C. Return RESPONSE_FILTER_DONE if all output data was written or
// RESPONSE_FILTER_NEED_MORE_DATA if output data is still pending.
//
// This method will be called repeatedly until the input buffer has been
// fully read (user sets |data_in_read| = |data_in_size|) and there is no
// more input data to filter (the resource response is complete). This method
// may then be called an additional time with an empty input buffer if the
// user filled the output buffer (set |data_out_written| = |data_out_size|)
// and returned RESPONSE_FILTER_NEED_MORE_DATA to indicate that output data is
// still pending.
//
// Calls to this method will stop when one of the following conditions is met:
//
// A. There is no more input data to filter (the resource response is
// complete) and the user sets |data_out_written| = 0 or returns
// RESPONSE_FILTER_DONE to indicate that all data has been written, or;
// B. The user returns RESPONSE_FILTER_ERROR to indicate an error.
//
// Do not keep a reference to the buffers passed to this method.
///
/*--cef(optional_param=data_in,default_retval=RESPONSE_FILTER_ERROR)--*/
virtual FilterStatus Filter(void* data_in,

6
include/internal/cef_types.h
View File

@ -563,12 +563,6 @@ typedef struct _cef_browser_settings_t {
///
cef_state_t javascript_dom_paste;
///
// Controls whether the caret position will be drawn. Also configurable using
// the "enable-caret-browsing" command-line switch.
///
cef_state_t caret_browsing;
///
// Controls whether any plugins will be loaded. Also configurable using the
// "disable-plugins" command-line switch.

1
include/internal/cef_types_wrappers.h
View File

@ -705,7 +705,6 @@ struct CefBrowserSettingsTraits {
target->javascript_close_windows = src->javascript_close_windows;
target->javascript_access_clipboard = src->javascript_access_clipboard;
target->javascript_dom_paste = src->javascript_dom_paste;
target->caret_browsing = src->caret_browsing;
target->plugins = src->plugins;
target->universal_access_from_file_urls =
src->universal_access_from_file_urls;

37
libcef/browser/browser_host_impl.cc
View File

@ -741,7 +741,8 @@ void CefBrowserHostImpl::Print() {
if (!actionable_contents)
return;
printing::CefPrintViewManager::FromWebContents(
actionable_contents)->PrintNow();
actionable_contents)->PrintNow(
actionable_contents->GetRenderViewHost()->GetMainFrame());
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefBrowserHostImpl::Print, this));
@ -762,7 +763,8 @@ void CefBrowserHostImpl::PrintToPDF(const CefString& path,
callback.get(), path);
}
printing::CefPrintViewManager::FromWebContents(actionable_contents)->
PrintToPDF(base::FilePath(path), settings, pdf_callback);
PrintToPDF(actionable_contents->GetMainFrame(), base::FilePath(path),
settings, pdf_callback);
} else {
CEF_POST_TASK(CEF_UIT,
base::Bind(&CefBrowserHostImpl::PrintToPDF, this, path, settings,
@ -1413,7 +1415,8 @@ void CefBrowserHostImpl::DestroyBrowser() {
menu_manager_->Destroy();
// Notify any observers that may have state associated with this browser.
FOR_EACH_OBSERVER(Observer, observers_, OnBrowserDestroyed(this));
for (auto& observer : observers_)
observer.OnBrowserDestroyed(this);
// Disassociate the platform delegate from this browser.
platform_delegate_->BrowserDestroyed(this);
@ -2108,7 +2111,8 @@ void CefBrowserHostImpl::UpdateTargetURL(content::WebContents* source,
}
}
bool CefBrowserHostImpl::AddMessageToConsole(content::WebContents* source,
bool CefBrowserHostImpl::DidAddMessageToConsole(
content::WebContents* source,
int32_t level,
const base::string16& message,
int32_t line_no,
@ -2355,11 +2359,6 @@ void CefBrowserHostImpl::RequestMediaAccessPermission(
bool webcam_requested =
(request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
if (microphone_requested || webcam_requested) {
switch (request.request_type) {
case content::MEDIA_OPEN_DEVICE_PEPPER_ONLY:
case content::MEDIA_DEVICE_ACCESS:
case content::MEDIA_GENERATE_STREAM:
case content::MEDIA_ENUMERATE_DEVICES:
// Pick the desired device or fall back to the first available of the
// given type.
if (microphone_requested) {
@ -2376,8 +2375,6 @@ void CefBrowserHostImpl::RequestMediaAccessPermission(
true,
&devices);
}
break;
}
}
callback.Run(devices, content::MEDIA_DEVICE_OK,
@ -3015,6 +3012,24 @@ gfx::Point CefBrowserHostImpl::GetScreenPoint(const gfx::Point& view) const {
return gfx::Point();
}
void CefBrowserHostImpl::StartDragging(
const content::DropData& drop_data,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh) {
if (platform_delegate_) {
platform_delegate_->StartDragging(drop_data, allowed_ops, image,
image_offset, event_info, source_rwh);
}
}
void CefBrowserHostImpl::UpdateDragCursor(blink::WebDragOperation operation) {
if (platform_delegate_)
platform_delegate_->UpdateDragCursor(operation);
}
void CefBrowserHostImpl::OnAddressChange(CefRefPtr<CefFrame> frame,
const GURL& url) {
if (client_.get()) {

16
libcef/browser/browser_host_impl.h
View File

@ -32,6 +32,11 @@
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/browser/web_contents_observer.h"
namespace content {
struct DragEventSourceInfo;
class RenderWidgetHostImpl;
}
namespace net {
class URLRequest;
}
@ -323,6 +328,15 @@ class CefBrowserHostImpl : public CefBrowserHost,
// scaling will be applied to the result.
gfx::Point GetScreenPoint(const gfx::Point& view) const;
void StartDragging(
const content::DropData& drop_data,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh);
void UpdateDragCursor(blink::WebDragOperation operation);
// Thread safe accessors.
const CefBrowserSettings& settings() const { return settings_; }
CefRefPtr<CefClient> client() const { return client_; }
@ -365,7 +379,7 @@ class CefBrowserHostImpl : public CefBrowserHost,
void CloseContents(content::WebContents* source) override;
void UpdateTargetURL(content::WebContents* source,
const GURL& url) override;
bool AddMessageToConsole(content::WebContents* source,
bool DidAddMessageToConsole(content::WebContents* source,
int32_t level,
const base::string16& message,
int32_t line_no,

3
libcef/browser/browser_main.cc
View File

@ -18,6 +18,7 @@
#include "libcef/browser/extensions/extensions_browser_client.h"
#include "libcef/browser/extensions/extension_system_factory.h"
#include "libcef/browser/net/chrome_scheme_handler.h"
#include "libcef/browser/printing/printing_message_filter.h"
#include "libcef/browser/thread_util.h"
#include "libcef/common/extensions/extensions_client.h"
#include "libcef/common/extensions/extensions_util.h"
@ -181,6 +182,8 @@ void CefBrowserMainParts::PreMainMessageLoopRun() {
extensions::CefExtensionSystemFactory::GetInstance();
}
printing::CefPrintingMessageFilter::EnsureShutdownNotifierFactoryBuilt();
CefRequestContextSettings settings;
CefContext::Get()->PopulateRequestContextSettings(&settings);

15
libcef/browser/browser_platform_delegate.cc
View File

@ -177,6 +177,21 @@ void CefBrowserPlatformDelegate::DragTargetDrop(const CefMouseEvent& event) {
NOTREACHED();
}
void CefBrowserPlatformDelegate::StartDragging(
const content::DropData& drop_data,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh) {
NOTREACHED();
}
void CefBrowserPlatformDelegate::UpdateDragCursor(
blink::WebDragOperation operation) {
NOTREACHED();
}
void CefBrowserPlatformDelegate::DragSourceEndedAt(
int x, int y,
cef_drag_operations_mask_t op) {

8
libcef/browser/browser_platform_delegate.h
View File

@ -244,6 +244,14 @@ class CefBrowserPlatformDelegate {
cef_drag_operations_mask_t allowed_ops);
virtual void DragTargetDragLeave();
virtual void DragTargetDrop(const CefMouseEvent& event);
virtual void StartDragging(
const content::DropData& drop_data,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh);
virtual void UpdateDragCursor(blink::WebDragOperation operation);
virtual void DragSourceEndedAt(int x, int y,
cef_drag_operations_mask_t op);
virtual void DragSourceSystemDragEnded();

2
libcef/browser/browser_urlrequest_impl.cc
View File

@ -82,7 +82,7 @@ class NET_EXPORT CefURLFetcherResponseWriter :
return num_bytes;
}
int Finish(const net::CompletionCallback& callback) override {
int Finish(int net_error, const net::CompletionCallback& callback) override {
if (url_request_.get())
url_request_ = NULL;
return net::OK;

40
libcef/browser/content_browser_client.cc
View File

@ -39,7 +39,9 @@
#include "base/base_switches.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/json/json_reader.h"
#include "base/path_service.h"
#include "cef/grit/cef_resources.h"
#include "chrome/browser/spellchecker/spellcheck_message_filter.h"
#include "chrome/common/chrome_switches.h"
#include "components/navigation_interception/intercept_navigation_throttle.h"
@ -60,6 +62,7 @@
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/resource_dispatcher_host.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/service_names.mojom.h"
#include "content/public/common/storage_quota_params.h"
#include "content/public/common/web_preferences.h"
#include "extensions/browser/extensions_browser_client.h"
@ -72,6 +75,7 @@
#include "net/ssl/ssl_cert_request_info.h"
#include "ppapi/host/ppapi_host.h"
#include "third_party/WebKit/public/web/WebWindowFeatures.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/ui_base_switches.h"
#include "url/gurl.h"
@ -457,9 +461,10 @@ void CefContentBrowserClient::RenderProcessWillLaunch(
const base::CommandLine* command_line =
base::CommandLine::ForCurrentProcess();
const int id = host->GetID();
Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
host->GetChannel()->AddFilter(new CefBrowserMessageFilter(id));
host->AddFilter(new printing::CefPrintingMessageFilter(id));
host->AddFilter(new printing::CefPrintingMessageFilter(id, profile));
if (!command_line->HasSwitch(switches::kDisableSpellChecking)) {
host->AddFilter(new SpellCheckMessageFilter(id));
@ -468,18 +473,16 @@ void CefContentBrowserClient::RenderProcessWillLaunch(
#endif
}
content::BrowserContext* browser_context = host->GetBrowserContext();
host->AddFilter(new CefPluginInfoMessageFilter(id,
static_cast<CefBrowserContext*>(browser_context)));
static_cast<CefBrowserContext*>(profile)));
if (extensions::ExtensionsEnabled()) {
host->AddFilter(
new extensions::ExtensionMessageFilter(id, browser_context));
new extensions::ExtensionMessageFilter(id, profile));
host->AddFilter(
new extensions::IOThreadExtensionMessageFilter(id, browser_context));
new extensions::IOThreadExtensionMessageFilter(id, profile));
host->AddFilter(
new extensions::ExtensionsGuestViewMessageFilter(id, browser_context));
new extensions::ExtensionsGuestViewMessageFilter(id, profile));
}
// If the renderer process crashes then the host may already have
@ -489,7 +492,7 @@ void CefContentBrowserClient::RenderProcessWillLaunch(
host->AddObserver(CefBrowserInfoManager::GetInstance());
host->Send(new CefProcessMsg_SetIsIncognitoProcess(
browser_context->IsOffTheRecord()));
profile->IsOffTheRecord()));
}
bool CefContentBrowserClient::ShouldUseProcessPerSite(
@ -587,6 +590,25 @@ void CefContentBrowserClient::SiteInstanceDeleting(
site_instance->GetId()));
}
std::unique_ptr<base::Value>
CefContentBrowserClient::GetServiceManifestOverlay(
const std::string& name) {
int id = -1;
if (name == content::mojom::kBrowserServiceName)
id = IDR_CEF_BROWSER_MANIFEST_OVERLAY;
else if (name == content::mojom::kRendererServiceName)
id = IDR_CEF_RENDERER_MANIFEST_OVERLAY;
else if (name == content::mojom::kUtilityServiceName)
id = IDR_CEF_UTILITY_MANIFEST_OVERLAY;
if (id == -1)
return nullptr;
base::StringPiece manifest_contents =
ui::ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
id, ui::ScaleFactor::SCALE_FACTOR_NONE);
return base::JSONReader::Read(manifest_contents);
}
void CefContentBrowserClient::AppendExtraCommandLineSwitches(
base::CommandLine* command_line, int child_process_id) {
const base::CommandLine* browser_cmd =
@ -660,7 +682,7 @@ void CefContentBrowserClient::AppendExtraCommandLineSwitches(
command_line->CopySwitchesFrom(*browser_cmd, kSwitchNames,
arraysize(kSwitchNames));
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
if (!browser_cmd->HasSwitch(switches::kNoSandbox)) {
// Pass the Widevine CDM path to the Zygote process. See comments in
// CefWidevineLoader::AddPepperPlugins.

4
libcef/browser/content_browser_client.h
View File

@ -46,6 +46,8 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
bool IsHandledURL(const GURL& url) override;
void SiteInstanceGotProcess(content::SiteInstance* site_instance) override;
void SiteInstanceDeleting(content::SiteInstance* site_instance) override;
std::unique_ptr<base::Value> GetServiceManifestOverlay(
const std::string& name) override;
void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id) override;
content::QuotaPermissionContext*
@ -104,7 +106,7 @@ class CefContentBrowserClient : public content::ContentBrowserClient {
#endif
#if defined(OS_WIN)
const wchar_t* GetResourceDllName() override;
const wchar_t* GetResourceDllName();
bool PreSpawnRenderer(sandbox::TargetPolicy* policy) override;
#endif

2
libcef/browser/context.cc
View File

@ -398,7 +398,7 @@ void CefContext::OnContextInitialized() {
static_cast<ChromeBrowserProcessStub*>(g_browser_process)->
OnContextInitialized();
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
CefWidevineLoader::GetInstance()->OnContextInitialized();
#endif

5
libcef/browser/devtools_frontend.cc
View File

@ -48,7 +48,7 @@ class ResponseWriter : public net::URLFetcherResponseWriter {
int Write(net::IOBuffer* buffer,
int num_bytes,
const net::CompletionCallback& callback) override;
int Finish(const net::CompletionCallback& callback) override;
int Finish(int net_error, const net::CompletionCallback& callback) override;
private:
base::WeakPtr<CefDevToolsFrontend> shell_devtools_;
@ -89,7 +89,8 @@ int ResponseWriter::Write(net::IOBuffer* buffer,
return num_bytes;
}
int ResponseWriter::Finish(const net::CompletionCallback& callback) {
int ResponseWriter::Finish(int net_error,
const net::CompletionCallback& callback) {
return net::OK;
}

10
libcef/browser/javascript_dialog_manager.cc
View File

@ -195,8 +195,10 @@ void CefJavaScriptDialogManager::RunBeforeUnloadDialog(
weak_ptr_factory_.GetWeakPtr(), callback));
}
void CefJavaScriptDialogManager::CancelActiveAndPendingDialogs(
content::WebContents* web_contents) {
void CefJavaScriptDialogManager::CancelDialogs(
content::WebContents* web_contents,
bool suppress_callbacks,
bool reset_state) {
CefRefPtr<CefClient> client = browser_->GetClient();
if (client.get()) {
CefRefPtr<CefJSDialogHandler> handler = client->GetJSDialogHandler();
@ -212,10 +214,6 @@ void CefJavaScriptDialogManager::CancelActiveAndPendingDialogs(
}
}
void CefJavaScriptDialogManager::ResetDialogState(
content::WebContents* web_contents) {
}
void CefJavaScriptDialogManager::DialogClosed(
const DialogClosedCallback& callback,
bool success,

7
libcef/browser/javascript_dialog_manager.h
View File

@ -41,10 +41,9 @@ class CefJavaScriptDialogManager : public content::JavaScriptDialogManager {
content::WebContents* web_contents,
bool is_reload,
const DialogClosedCallback& callback) override;
void CancelActiveAndPendingDialogs(
content::WebContents* web_contents) override;
void ResetDialogState(
content::WebContents* web_contents) override;
void CancelDialogs(content::WebContents* web_contents,
bool suppress_callbacks,
bool reset_state) override;
private:
// Method executed by the callback passed to CefJavaScriptDialogRunner::Run.

6
libcef/browser/menu_model_impl.cc
View File

@ -654,7 +654,8 @@ void CefMenuModelImpl::MenuWillShow() {
delegate_->MenuWillShow(this);
if (menu_model_delegate_)
menu_model_delegate_->MenuWillShow(this);
FOR_EACH_OBSERVER(Observer, observers_, MenuWillShow(this));
for (auto& observer : observers_)
observer.MenuWillShow(this);
}
void CefMenuModelImpl::MenuWillClose() {
@ -776,7 +777,8 @@ void CefMenuModelImpl::OnMenuClosed() {
delegate_->MenuClosed(this);
if (menu_model_delegate_)
menu_model_delegate_->MenuClosed(this);
FOR_EACH_OBSERVER(Observer, observers_, MenuClosed(this));
for (auto& observer : observers_)
observer.MenuClosed(this);
}
bool CefMenuModelImpl::VerifyContext() {

2
libcef/browser/native/browser_platform_delegate_native_mac.mm
View File

@ -20,7 +20,7 @@
#include "content/public/browser/native_web_keyboard_event.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/web_contents.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "third_party/WebKit/public/platform/WebInputEvent.h"
#import "ui/base/cocoa/cocoa_base_utils.h"
#import "ui/base/cocoa/underlay_opengl_hosting_window.h"
#include "ui/events/keycodes/keyboard_codes_posix.h"

15
libcef/browser/native/native_menu_win.cc
View File

@ -8,6 +8,7 @@
#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
@ -404,7 +405,6 @@ CefNativeMenuWin::CefNativeMenuWin(ui::MenuModel* model, HWND system_menu_for)
CefNativeMenuWin::~CefNativeMenuWin() {
if (destroyed_flag_)
*destroyed_flag_ = true;
base::STLDeleteContainerPointers(items_.begin(), items_.end());
DestroyMenu(menu_);
}
@ -485,7 +485,7 @@ void CefNativeMenuWin::Rebuild(MenuInsertionDelegateWin* delegate) {
void CefNativeMenuWin::UpdateStates() {
// A depth-first walk of the menu items, updating states.
int model_index = 0;
std::vector<ItemData*>::const_iterator it;
ItemDataList::const_iterator it;
for (it = items_.begin(); it != items_.end(); ++it, ++model_index) {
int menu_index = model_index + first_item_index_;
SetMenuItemState(menu_index, model_->IsEnabledAt(model_index),
@ -567,7 +567,8 @@ LRESULT CALLBACK CefNativeMenuWin::MenuMessageHook(
// The first time this hook is called, that means the menu has successfully
// opened, so call the callback function on all of our listeners.
if (!this_ptr->listeners_called_) {
FOR_EACH_OBSERVER(MenuListener, this_ptr->listeners_, OnMenuOpened());
for (auto& observer : this_ptr->listeners_)
observer.OnMenuOpened();
this_ptr->listeners_called_ = true;
}
@ -622,7 +623,7 @@ void CefNativeMenuWin::AddMenuItemAt(int menu_index, int model_index) {
else
mii.fType = MFT_OWNERDRAW;
ItemData* item_data = new ItemData;
std::unique_ptr<ItemData> item_data = base::MakeUnique<ItemData>();
item_data->label = base::string16();
ui::MenuModel::ItemType type = model_->GetTypeAt(model_index);
if (type == ui::MenuModel::TYPE_SUBMENU) {
@ -637,8 +638,8 @@ void CefNativeMenuWin::AddMenuItemAt(int menu_index, int model_index) {
}
item_data->native_menu_win = this;
item_data->model_index = model_index;
items_.insert(items_.begin() + model_index, item_data);
mii.dwItemData = reinterpret_cast<ULONG_PTR>(item_data);
mii.dwItemData = reinterpret_cast<ULONG_PTR>(item_data.get());
items_.insert(items_.begin() + model_index, std::move(item_data));
UpdateMenuItemInfoForString(&mii, model_index,
model_->GetLabelAt(model_index));
InsertMenuItem(menu_, menu_index, TRUE, &mii);
@ -651,7 +652,7 @@ void CefNativeMenuWin::AddSeparatorItemAt(int menu_index, int model_index) {
mii.fType = MFT_SEPARATOR;
// Insert a dummy entry into our label list so we can index directly into it
// using item indices if need be.
items_.insert(items_.begin() + model_index, new ItemData);
items_.insert(items_.begin() + model_index, base::MakeUnique<ItemData>());
InsertMenuItem(menu_, menu_index, TRUE, &mii);
}

4
libcef/browser/native/native_menu_win.h
View File

@ -5,6 +5,7 @@
#ifndef CEF_LIBCEF_BROWSER_NATIVE_NATIVE_MENU_WIN_H_
#define CEF_LIBCEF_BROWSER_NATIVE_NATIVE_MENU_WIN_H_
#include <memory>
#include <vector>
#include "libcef/browser/native/menu_wrapper.h"
@ -119,7 +120,8 @@ class CefNativeMenuWin : public MenuWrapper {
// An object that collects all of the data associated with an individual menu
// item.
struct ItemData;
std::vector<ItemData*> items_;
typedef std::vector<std::unique_ptr<ItemData>> ItemDataList;
ItemDataList items_;
// The window that receives notifications from the menu.
class MenuHostWindow;

94
libcef/browser/net/network_delegate.cc
View File

@ -9,7 +9,7 @@
#include "include/cef_urlrequest.h"
#include "libcef/browser/browser_host_impl.h"
#include "libcef/browser/net/response_filter_wrapper.h"
#include "libcef/browser/net/source_stream.h"
#include "libcef/browser/net/url_request_user_data.h"
#include "libcef/browser/thread_util.h"
#include "libcef/common/request_impl.h"
@ -23,16 +23,11 @@
#include "components/prefs/pref_service.h"
#include "content/public/common/content_switches.h"
#include "net/base/net_errors.h"
#include "net/filter/filter.h"
#include "net/http/http_util.h"
#include "net/url_request/url_request.h"
namespace {
// Buffer size allocated when filtering data.
// Should match the value in net/filter/filter.cc.
const int kFilterBufSize = 32 * 1024;
class CefBeforeResourceLoadCallbackImpl : public CefRequestCallback {
public:
typedef net::CompletionCallback CallbackType;
@ -266,6 +261,41 @@ bool CefNetworkDelegate::AreStrictSecureCookiesEnabled() {
base::CompareCase::INSENSITIVE_ASCII);
}
std::unique_ptr<net::SourceStream> CefNetworkDelegate::CreateSourceStream(
net::URLRequest* request,
std::unique_ptr<net::SourceStream> upstream) {
CefRefPtr<CefResponseFilter> cef_filter;
CefRefPtr<CefBrowserHostImpl> browser =
CefBrowserHostImpl::GetBrowserForRequest(request);
if (browser.get()) {
CefRefPtr<CefClient> client = browser->GetClient();
if (client.get()) {
CefRefPtr<CefRequestHandler> handler = client->GetRequestHandler();
if (handler.get()) {
CefRefPtr<CefFrame> frame = browser->GetFrameForRequest(request);
CefRefPtr<CefRequestImpl> cefRequest = new CefRequestImpl();
cefRequest->Set(request);
cefRequest->SetReadOnly(true);
CefRefPtr<CefResponseImpl> cefResponse = new CefResponseImpl();
cefResponse->Set(request);
cefResponse->SetReadOnly(true);
cef_filter = handler->GetResourceResponseFilter(browser.get(), frame,
cefRequest.get(),
cefResponse.get());
}
}
}
if (cef_filter && cef_filter->InitFilter())
return base::MakeUnique<CefSourceStream>(cef_filter, std::move(upstream));
return upstream;
}
int CefNetworkDelegate::OnBeforeURLRequest(
net::URLRequest* request,
const net::CompletionCallback& callback,
@ -442,55 +472,3 @@ bool CefNetworkDelegate::OnAreExperimentalCookieFeaturesEnabled() const {
bool CefNetworkDelegate::OnAreStrictSecureCookiesEnabled() const {
return AreStrictSecureCookiesEnabled();
}
net::Filter* CefNetworkDelegate::SetupFilter(net::URLRequest* request,
net::Filter* filter_list) {
CefRefPtr<CefResponseFilter> cef_filter;
CefRefPtr<CefBrowserHostImpl> browser =
CefBrowserHostImpl::GetBrowserForRequest(request);
if (browser.get()) {
CefRefPtr<CefClient> client = browser->GetClient();
if (client.get()) {
CefRefPtr<CefRequestHandler> handler = client->GetRequestHandler();
if (handler.get()) {
CefRefPtr<CefFrame> frame = browser->GetFrameForRequest(request);
CefRefPtr<CefRequestImpl> cefRequest = new CefRequestImpl();
cefRequest->Set(request);
cefRequest->SetReadOnly(true);
CefRefPtr<CefResponseImpl> cefResponse = new CefResponseImpl();
cefResponse->Set(request);
cefResponse->SetReadOnly(true);
cef_filter = handler->GetResourceResponseFilter(browser.get(), frame,
cefRequest.get(),
cefResponse.get());
}
}
}
if (cef_filter.get() && cef_filter->InitFilter()) {
std::unique_ptr<CefResponseFilterWrapper> wrapper(
new CefResponseFilterWrapper(cef_filter, filter_list != nullptr));
wrapper->InitBuffer(kFilterBufSize);
if (filter_list) {
// Install the wrapper at the end of the filter list.
net::Filter* last_filter = filter_list;
do {
if (!last_filter->next_filter_.get()) {
last_filter->next_filter_ = std::move(wrapper);
break;
}
last_filter = last_filter->next_filter_.get();
} while (last_filter);
} else {
// Only the wrapper exists.
filter_list = wrapper.release();
}
}
return filter_list;
}

5
libcef/browser/net/network_delegate.h
View File

@ -31,6 +31,9 @@ class CefNetworkDelegate : public net::NetworkDelegateImpl {
private:
// net::NetworkDelegate methods.
std::unique_ptr<net::SourceStream> CreateSourceStream(
net::URLRequest* request,
std::unique_ptr<net::SourceStream> upstream) override;
int OnBeforeURLRequest(net::URLRequest* request,
const net::CompletionCallback& callback,
GURL* new_url) override;
@ -44,8 +47,6 @@ class CefNetworkDelegate : public net::NetworkDelegateImpl {
const base::FilePath& path) const override;
bool OnAreExperimentalCookieFeaturesEnabled() const override;
bool OnAreStrictSecureCookiesEnabled() const override;
net::Filter* SetupFilter(net::URLRequest* request,
net::Filter* filter_list) override;
// Weak, owned by our owner (CefURLRequestContextGetterImpl).
BooleanPrefMember* force_google_safesearch_;

71
libcef/browser/net/response_filter_wrapper.cc
View File

@ -1,71 +0,0 @@
// Copyright 2014 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 "libcef/browser/net/response_filter_wrapper.h"
#include "base/logging.h"
// FilterType is used for logging purposes only.
CefResponseFilterWrapper::CefResponseFilterWrapper(
CefRefPtr<CefResponseFilter> cef_filter,
bool has_other_filters)
: Filter(Filter::FILTER_TYPE_UNSUPPORTED),
cef_filter_(cef_filter),
has_other_filters_(has_other_filters) {
DCHECK(cef_filter_.get());
}
CefResponseFilterWrapper::~CefResponseFilterWrapper() {
}
net::Filter::FilterStatus CefResponseFilterWrapper::ReadFilteredData(
char* dest_buffer,
int* dest_len) {
if (!dest_buffer || !dest_len || *dest_len <= 0)
return net::Filter::FILTER_ERROR;
size_t data_in_size = static_cast<size_t>(stream_data_len_);
size_t data_in_read = 0;
size_t data_out_size = static_cast<size_t>(*dest_len);
size_t data_out_write = 0;
cef_response_filter_status_t cef_status = cef_filter_->Filter(
next_stream_data_, data_in_size, data_in_read,
dest_buffer, data_out_size, data_out_write);
// Return early if there's an error.
if (cef_status == RESPONSE_FILTER_ERROR)
return net::Filter::FILTER_ERROR;
// Normalize the out values.
if (data_in_read > data_in_size) {
LOG(ERROR) <<
"potential buffer overflow; data_in_read exceeds data_in_size";
data_in_read = data_in_size;
}
if (data_out_write > data_out_size) {
LOG(ERROR) <<
"potential buffer overflow; data_out_write exceeds data_out_size";
data_out_write = data_out_size;
}
// Output the number of bytes written.
*dest_len = static_cast<int>(data_out_write);
if (data_in_size - data_in_read > 0U) {
// There are bytes left so adjust the stream pointer and return FILTER_OK.
next_stream_data_ += data_in_read;
stream_data_len_ -= static_cast<int>(data_in_read);
return Filter::FILTER_OK;
}
// No bytes left. Might need more data or might be done.
// If |has_other_filters_| is true then we must return FILTER_NEED_MORE_DATA
// or additional data will not be sent.
next_stream_data_ = nullptr;
stream_data_len_ = 0;
if (cef_status == RESPONSE_FILTER_NEED_MORE_DATA || has_other_filters_)
return Filter::FILTER_NEED_MORE_DATA;
return Filter::FILTER_DONE;
}

41
libcef/browser/net/response_filter_wrapper.h
View File

@ -1,41 +0,0 @@
// Copyright 2015 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.
#ifndef CEF_LIBCEF_BROWSER_NET_RESPONSE_FILTER_WRAPPER_H_
#define CEF_LIBCEF_BROWSER_NET_RESPONSE_FILTER_WRAPPER_H_
#include "include/cef_response_filter.h"
#include "base/macros.h"
#include "net/filter/filter.h"
class CefResponseFilterWrapper : public net::Filter {
public:
CefResponseFilterWrapper(CefRefPtr<CefResponseFilter> cef_filter,
bool has_other_filters);
~CefResponseFilterWrapper() override;
// Decodes the pre-filter data and writes the output into the dest_buffer
// passed in.
// The function returns FilterStatus. See filter.h for its description.
//
// Upon entry, *dest_len is the total size (in number of chars) of the
// destination buffer. Upon exit, *dest_len is the actual number of chars
// written into the destination buffer.
//
// This function will fail if there is no pre-filter data in the
// stream_buffer_. On the other hand, *dest_len can be 0 upon successful
// return. For example, the internal filter may process some pre-filter data
// but not produce output yet.
FilterStatus ReadFilteredData(char* dest_buffer, int* dest_len) override;
private:
CefRefPtr<CefResponseFilter> cef_filter_;
const bool has_other_filters_;
DISALLOW_COPY_AND_ASSIGN(CefResponseFilterWrapper);
};
#endif // CEF_LIBCEF_BROWSER_NET_RESPONSE_FILTER_WRAPPER_H_

7
libcef/browser/net/scheme_handler.cc
View File

@ -14,6 +14,7 @@
#include "base/threading/sequenced_worker_pool.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/common/url_constants.h"
#include "net/net_features.h"
#include "net/url_request/data_protocol_handler.h"
#include "net/url_request/file_protocol_handler.h"
#include "net/url_request/ftp_protocol_handler.h"
@ -26,7 +27,7 @@ void InstallInternalProtectedHandlers(
net::URLRequestJobFactoryImpl* job_factory,
CefURLRequestManager* request_manager,
content::ProtocolHandlerMap* protocol_handlers,
net::FtpTransactionFactory* ftp_transaction_factory) {
net::HostResolver* host_resolver) {
protocol_handlers->insert(
std::make_pair(url::kDataScheme,
linked_ptr<net::URLRequestJobFactory::ProtocolHandler>(
@ -38,11 +39,11 @@ void InstallInternalProtectedHandlers(
content::BrowserThread::GetBlockingPool()->
GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)))));
#if !defined(DISABLE_FTP_SUPPORT)
#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
protocol_handlers->insert(
std::make_pair(url::kFtpScheme,
linked_ptr<net::URLRequestJobFactory::ProtocolHandler>(
new net::FtpProtocolHandler(ftp_transaction_factory))));
net::FtpProtocolHandler::Create(host_resolver).release())));
#endif
for (content::ProtocolHandlerMap::iterator it =

4
libcef/browser/net/scheme_handler.h
View File

@ -12,7 +12,7 @@
#include "url/gurl.h"
namespace net {
class FtpTransactionFactory;
class HostResolver;
class URLRequestJobFactoryImpl;
}
@ -26,7 +26,7 @@ void InstallInternalProtectedHandlers(
net::URLRequestJobFactoryImpl* job_factory,
CefURLRequestManager* request_manager,
content::ProtocolHandlerMap* protocol_handlers,
net::FtpTransactionFactory* ftp_transaction_factory);
net::HostResolver* host_resolver);
// Register the internal scheme handlers that can be overridden.
void RegisterInternalHandlers(CefURLRequestManager* request_manager);

77
libcef/browser/net/source_stream.cc Normal file
View File

@ -0,0 +1,77 @@
// Copyright 2016 The Chromium Embedded Framework 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 "libcef/browser/net/source_stream.h"
#include <utility>
#include "net/base/io_buffer.h"
// Use TYPE_INVALID so that URLRequestJob::NotifyHeadersComplete() doesn't
// assume that the "content-length" header is accurate.
CefSourceStream::CefSourceStream(
CefRefPtr<CefResponseFilter> cef_filter,
std::unique_ptr<net::SourceStream> upstream)
: net::FilterSourceStream(net::SourceStream::TYPE_INVALID,
std::move(upstream)),
cef_filter_(cef_filter) {
}
int CefSourceStream::FilterData(net::IOBuffer* output_buffer,
int output_buffer_size,
net::IOBuffer* input_buffer,
int input_buffer_size,
int* consumed_bytes,
bool upstream_eof_reached) {
if (!output_buffer || output_buffer_size <= 0)
return net::ERR_CONTENT_DECODING_FAILED;
if (input_buffer_size == 0 && last_status_ == RESPONSE_FILTER_DONE) {
// No more input data. Respect the client's desire to be done with
// outputting data.
*consumed_bytes = 0;
return 0;
}
size_t data_in_size = static_cast<size_t>(input_buffer_size);
size_t data_in_read = 0;
size_t data_out_size = static_cast<size_t>(output_buffer_size);
size_t data_out_written = 0;
last_status_ = cef_filter_->Filter(
data_in_size > 0 ? input_buffer->data() : nullptr,
data_in_size, data_in_read,
output_buffer->data(), data_out_size, data_out_written);
// Return early if there's an error.
if (last_status_ == RESPONSE_FILTER_ERROR)
return net::ERR_CONTENT_DECODING_FAILED;
// Validate the out values.
if (data_in_read > data_in_size) {
LOG(ERROR) << "potential buffer overflow; data_in_read > data_in_size";
return net::ERR_CONTENT_DECODING_FAILED;
}
if (data_out_written > data_out_size) {
LOG(ERROR) << "potential buffer overflow; data_out_written > data_out_size";
return net::ERR_CONTENT_DECODING_FAILED;
}
// If FilterData() returns 0, *|consumed_bytes| must be equal to
// |input_buffer_size|.
if (data_out_written == 0 && data_in_read != data_in_size) {
LOG(ERROR) << "when no data is written all input must be consumed; "
"data_out_written == 0 && data_in_read != data_in_size";
return net::ERR_CONTENT_DECODING_FAILED;
}
*consumed_bytes = static_cast<int>(data_in_read);
// Output the number of bytes written.
return static_cast<int>(data_out_written);
}
std::string CefSourceStream::GetTypeAsString() const {
return "cef_filter";
}

34
libcef/browser/net/source_stream.h Normal file
View File

@ -0,0 +1,34 @@
// Copyright 2016 The Chromium Embedded Framework Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CEF_LIBCEF_BROWSER_NET_SOURCE_STREAM_H_
#define CEF_LIBCEF_BROWSER_NET_SOURCE_STREAM_H_
#include "include/cef_response_filter.h"
#include "base/macros.h"
#include "net/filter/filter_source_stream.h"
class CefSourceStream : public net::FilterSourceStream {
public:
CefSourceStream(CefRefPtr<CefResponseFilter> cef_filter,
std::unique_ptr<net::SourceStream> upstream);
int FilterData(net::IOBuffer* output_buffer,
int output_buffer_size,
net::IOBuffer* input_buffer,
int input_buffer_size,
int* consumed_bytes,
bool upstream_eof_reached) override;
std::string GetTypeAsString() const override;
private:
CefRefPtr<CefResponseFilter> cef_filter_;
cef_response_filter_status_t last_status_ = RESPONSE_FILTER_NEED_MORE_DATA;
DISALLOW_COPY_AND_ASSIGN(CefSourceStream);
};
#endif // CEF_LIBCEF_BROWSER_NET_SOURCE_STREAM_H_

10
libcef/browser/net/url_request_context_getter_impl.cc
View File

@ -322,20 +322,16 @@ net::URLRequestContext* CefURLRequestContextGetterImpl::GetURLRequestContext() {
std::move(main_backend),
true /* set_up_quic_server_info */)));
#if !defined(DISABLE_FTP_SUPPORT)
ftp_transaction_factory_.reset(
new net::FtpNetworkLayer(network_session_params.host_resolver));
#endif
std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(
new net::URLRequestJobFactoryImpl());
url_request_manager_.reset(new CefURLRequestManager(job_factory.get()));
// Install internal scheme handlers that cannot be overridden.
scheme::InstallInternalProtectedHandlers(job_factory.get(),
scheme::InstallInternalProtectedHandlers(
job_factory.get(),
url_request_manager_.get(),
&protocol_handlers_,
ftp_transaction_factory_.get());
network_session_params.host_resolver);
protocol_handlers_.clear();
// Register internal scheme handlers that can be overridden.

1
libcef/browser/net/url_request_context_getter_impl.h
View File

@ -105,7 +105,6 @@ class CefURLRequestContextGetterImpl : public CefURLRequestContextGetter {
std::unique_ptr<net::HttpAuthPreferences> http_auth_preferences_;
std::unique_ptr<CefURLRequestContextImpl> url_request_context_;
std::unique_ptr<CefURLRequestManager> url_request_manager_;
std::unique_ptr<net::FtpTransactionFactory> ftp_transaction_factory_;
content::ProtocolHandlerMap protocol_handlers_;
content::URLRequestInterceptorScopedVector request_interceptors_;

161
libcef/browser/osr/browser_platform_delegate_osr.cc
View File

@ -11,6 +11,8 @@
#include "libcef/browser/osr/web_contents_view_osr.h"
#include "libcef/common/drag_data_impl.h"
#include "content/browser/renderer_host/render_widget_host_input_event_router.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/browser/render_view_host.h"
CefBrowserPlatformDelegateOsr::CefBrowserPlatformDelegateOsr(
@ -247,52 +249,119 @@ void CefBrowserPlatformDelegateOsr::DragTargetDragEnter(
CefRefPtr<CefDragData> drag_data,
const CefMouseEvent& event,
cef_drag_operations_mask_t allowed_ops) {
content::RenderViewHost* rvh = browser_->web_contents()->GetRenderViewHost();
if (!rvh)
content::WebContentsImpl* web_contents =
static_cast<content::WebContentsImpl*>(browser_->web_contents());
if (!web_contents)
return;
if (current_rvh_for_drag_)
DragTargetDragLeave();
const gfx::Point client_pt(event.x, event.y);
gfx::Point transformed_pt;
current_rwh_for_drag_ =
web_contents->GetInputEventRouter()->GetRenderWidgetHostAtPoint(
web_contents->GetRenderViewHost()->GetWidget()->GetView(),
client_pt, &transformed_pt)->GetWeakPtr();
current_rvh_for_drag_ = web_contents->GetRenderViewHost();
drag_data_ = drag_data;
drag_allowed_ops_ = allowed_ops;
CefDragDataImpl* data_impl = static_cast<CefDragDataImpl*>(drag_data.get());
base::AutoLock lock_scope(data_impl->lock());
content::DropData* drop_data = data_impl->drop_data();
const gfx::Point client_pt(event.x, event.y);
const gfx::Point& screen_pt = GetScreenPoint(client_pt);
blink::WebDragOperationsMask ops =
static_cast<blink::WebDragOperationsMask>(allowed_ops);
int modifiers = TranslateModifiers(event.modifiers);
rvh->FilterDropData(drop_data);
rvh->DragTargetDragEnter(*drop_data, client_pt, screen_pt, ops, modifiers);
current_rwh_for_drag_->FilterDropData(drop_data);
// Give the delegate an opportunity to cancel the drag.
if (web_contents->GetDelegate() &&
!web_contents->GetDelegate()->CanDragEnter(
web_contents, *drop_data, ops)) {
drag_data_ = nullptr;
return;
}
current_rwh_for_drag_->DragTargetDragEnter(
*drop_data, transformed_pt, screen_pt, ops, modifiers);
}
void CefBrowserPlatformDelegateOsr::DragTargetDragOver(
const CefMouseEvent& event,
cef_drag_operations_mask_t allowed_ops) {
content::RenderViewHost* rvh = browser_->web_contents()->GetRenderViewHost();
if (!rvh)
if (!drag_data_)
return;
content::WebContentsImpl* web_contents =
static_cast<content::WebContentsImpl*>(browser_->web_contents());
if (!web_contents)
return;
const gfx::Point client_pt(event.x, event.y);
gfx::Point transformed_pt;
content::RenderWidgetHostImpl* target_rwh =
web_contents->GetInputEventRouter()->GetRenderWidgetHostAtPoint(
web_contents->GetRenderViewHost()->GetWidget()->GetView(),
client_pt, &transformed_pt);
if (target_rwh != current_rwh_for_drag_.get()) {
if (current_rwh_for_drag_)
current_rwh_for_drag_->DragTargetDragLeave();
DragTargetDragEnter(drag_data_, event, drag_allowed_ops_);
}
if (!drag_data_)
return;
const gfx::Point& screen_pt = GetScreenPoint(client_pt);
blink::WebDragOperationsMask ops =
static_cast<blink::WebDragOperationsMask>(allowed_ops);
int modifiers = TranslateModifiers(event.modifiers);
rvh->DragTargetDragOver(client_pt, screen_pt, ops, modifiers);
target_rwh->DragTargetDragOver(transformed_pt, screen_pt, ops, modifiers);
}
void CefBrowserPlatformDelegateOsr::DragTargetDragLeave() {
content::RenderViewHost* rvh = browser_->web_contents()->GetRenderViewHost();
if (!rvh)
if (current_rvh_for_drag_ != browser_->web_contents()->GetRenderViewHost() ||
!drag_data_) {
return;
}
rvh->DragTargetDragLeave();
if (current_rwh_for_drag_) {
current_rwh_for_drag_->DragTargetDragLeave();
current_rwh_for_drag_.reset();
}
drag_data_ = nullptr;
}
void CefBrowserPlatformDelegateOsr::DragTargetDrop(const CefMouseEvent& event) {
content::RenderViewHost* rvh = browser_->web_contents()->GetRenderViewHost();
if (!rvh)
if (!drag_data_)
return;
content::WebContentsImpl* web_contents =
static_cast<content::WebContentsImpl*>(browser_->web_contents());
if (!web_contents)
return;
gfx::Point client_pt(event.x, event.y);
gfx::Point transformed_pt;
content::RenderWidgetHostImpl* target_rwh =
web_contents->GetInputEventRouter()->GetRenderWidgetHostAtPoint(
web_contents->GetRenderViewHost()->GetWidget()->GetView(),
client_pt, &transformed_pt);
if (target_rwh != current_rwh_for_drag_.get()) {
if (current_rwh_for_drag_)
current_rwh_for_drag_->DragTargetDragLeave();
DragTargetDragEnter(drag_data_, event, drag_allowed_ops_);
}
if (!drag_data_)
return;
{
@ -300,35 +369,85 @@ void CefBrowserPlatformDelegateOsr::DragTargetDrop(const CefMouseEvent& event) {
static_cast<CefDragDataImpl*>(drag_data_.get());
base::AutoLock lock_scope(data_impl->lock());
content::DropData* drop_data = data_impl->drop_data();
const gfx::Point client_pt(event.x, event.y);
const gfx::Point& screen_pt = GetScreenPoint(client_pt);
int modifiers = TranslateModifiers(event.modifiers);
rvh->DragTargetDrop(*drop_data, client_pt, screen_pt, modifiers);
target_rwh->DragTargetDrop(*drop_data, transformed_pt, screen_pt,
modifiers);
}
drag_data_ = nullptr;
}
void CefBrowserPlatformDelegateOsr::StartDragging(
const content::DropData& drop_data,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh) {
drag_start_rwh_ = source_rwh->GetWeakPtr();
bool handled = false;
CefRefPtr<CefRenderHandler> handler =
browser_->GetClient()->GetRenderHandler();
if (handler.get()) {
CefRefPtr<CefDragDataImpl> drag_data(new CefDragDataImpl(drop_data));
drag_data->SetReadOnly(true);
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
handled = handler->StartDragging(
browser_,
drag_data.get(),
static_cast<CefRenderHandler::DragOperationsMask>(allowed_ops),
event_info.event_location.x(),
event_info.event_location.y());
}
if (!handled)
DragSourceSystemDragEnded();
}
void CefBrowserPlatformDelegateOsr::UpdateDragCursor(
blink::WebDragOperation operation) {
CefRefPtr<CefRenderHandler> handler =
browser_->GetClient()->GetRenderHandler();
if (handler.get()) {
handler->UpdateDragCursor(
browser_, static_cast<CefRenderHandler::DragOperation>(operation));
}
}
void CefBrowserPlatformDelegateOsr::DragSourceEndedAt(
int x, int y,
cef_drag_operations_mask_t op) {
content::RenderViewHost* rvh = browser_->web_contents()->GetRenderViewHost();
if (!rvh)
if (!drag_start_rwh_)
return;
content::WebContentsImpl* web_contents =
static_cast<content::WebContentsImpl*>(browser_->web_contents());
if (!web_contents)
return;
const gfx::Point& screen_pt = GetScreenPoint(gfx::Point(x, y));
blink::WebDragOperation drag_op = static_cast<blink::WebDragOperation>(op);
rvh->DragSourceEndedAt(x, y, screen_pt.x(), screen_pt.y(), drag_op);
web_contents->DragSourceEndedAt(x, y, screen_pt.x(), screen_pt.y(), drag_op,
drag_start_rwh_.get());
}
void CefBrowserPlatformDelegateOsr::DragSourceSystemDragEnded() {
content::RenderViewHost* rvh = browser_->web_contents()->GetRenderViewHost();
if (!rvh)
if (!drag_start_rwh_)
return;
rvh->DragSourceSystemDragEnded();
content::WebContents* web_contents = browser_->web_contents();
if (!web_contents)
return;
web_contents->SystemDragEnded(drag_start_rwh_.get());
drag_start_rwh_ = nullptr;
}
CefWindowHandle CefBrowserPlatformDelegateOsr::GetParentWindowHandle() const {

26
libcef/browser/osr/browser_platform_delegate_osr.h
View File

@ -11,6 +11,10 @@
class CefRenderWidgetHostViewOSR;
class CefWebContentsViewOSR;
namespace content {
class RenderWidgetHostImpl;
}
// Base implementation of windowless browser functionality.
class CefBrowserPlatformDelegateOsr :
public CefBrowserPlatformDelegate,
@ -72,6 +76,14 @@ class CefBrowserPlatformDelegateOsr :
cef_drag_operations_mask_t allowed_ops) override;
void DragTargetDragLeave() override;
void DragTargetDrop(const CefMouseEvent& event) override;
void StartDragging(
const content::DropData& drop_data,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh) override;
void UpdateDragCursor(blink::WebDragOperation operation) override;
void DragSourceEndedAt(int x, int y,
cef_drag_operations_mask_t op) override;
void DragSourceSystemDragEnded() override;
@ -95,6 +107,20 @@ class CefBrowserPlatformDelegateOsr :
// Pending drag/drop data.
CefRefPtr<CefDragData> drag_data_;
cef_drag_operations_mask_t drag_allowed_ops_;
// We keep track of the RenderWidgetHost we're dragging over. If it changes
// during a drag, we need to re-send the DragEnter message.
base::WeakPtr<content::RenderWidgetHostImpl> current_rwh_for_drag_;
// We also keep track of the RenderViewHost we're dragging over to avoid
// sending the drag exited message after leaving the current
// view. |current_rvh_for_drag_| should not be dereferenced.
void* current_rvh_for_drag_;
// We keep track of the RenderWidgetHost from which the current drag started,
// in order to properly route the drag end message to it.
base::WeakPtr<content::RenderWidgetHostImpl> drag_start_rwh_;
};
#endif // CEF_LIBCEF_BROWSER_OSR_BROWSER_PLATFORM_DELEGATE_OSR_H_

4
libcef/browser/osr/render_widget_host_view_osr.cc
View File

@ -1090,10 +1090,6 @@ CefRenderWidgetHostViewOSR::DelegatedFrameHostSendReclaimCompositorResources(
resources));
}
void CefRenderWidgetHostViewOSR::DelegatedFrameHostOnLostCompositorResources() {
render_widget_host_->ScheduleComposite();
}
void CefRenderWidgetHostViewOSR::SetBeginFrameSource(
cc::BeginFrameSource* source) {
// TODO(cef): Maybe we can use this method in combination with

1
libcef/browser/osr/render_widget_host_view_osr.h
View File

@ -190,7 +190,6 @@ class CefRenderWidgetHostViewOSR
int output_surface_id,
bool is_swap_ack,
const cc::ReturnedResourceArray& resources) override;
void DelegatedFrameHostOnLostCompositorResources() override;
void SetBeginFrameSource(cc::BeginFrameSource* source) override;
bool IsAutoResizeEnabled() const override;
#endif // !defined(OS_MACOSX)

4
libcef/browser/osr/render_widget_host_view_osr_mac.mm
View File

@ -58,10 +58,6 @@ class MacHelper :
is_swap_ack, resources));
}
void BrowserCompositorMacOnLostCompositorResources() override {
view_->render_widget_host()->ScheduleComposite();
}
void BrowserCompositorMacSendBeginFrame(
const cc::BeginFrameArgs& args) override {
view_->render_widget_host()->Send(

2
libcef/browser/osr/software_output_device_osr.cc
View File

@ -32,8 +32,6 @@ void CefSoftwareOutputDeviceOSR::Resize(const gfx::Size& viewport_pixel_size,
float scale_factor) {
CEF_REQUIRE_UIT();
scale_factor_ = scale_factor;
if (viewport_pixel_size_ == viewport_pixel_size)
return;

37
libcef/browser/osr/web_contents_view_osr.cc
View File

@ -197,7 +197,8 @@ void CefWebContentsViewOSR::StartDragging(
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info) {
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh) {
if (guest_) {
// Based on WebContentsViewGuest::StartDragging.
content::WebContentsImpl* embedder_web_contents =
@ -213,36 +214,24 @@ void CefWebContentsViewOSR::StartDragging(
content::RecordAction(
base::UserMetricsAction("BrowserPlugin.Guest.StartDrag"));
view->StartDragging(drop_data, allowed_ops, image, image_offset,
event_info);
event_info, source_rwh);
} else {
embedder_web_contents->SystemDragEnded();
embedder_web_contents->SystemDragEnded(source_rwh);
}
return;
}
CefRefPtr<CefBrowserHostImpl> browser;
CefRefPtr<CefRenderHandler> handler;
bool handled = false;
CefRenderWidgetHostViewOSR* view =
static_cast<CefRenderWidgetHostViewOSR*>(view_);
if (view)
browser = view->browser_impl();
if (browser.get())
handler = browser->GetClient()->GetRenderHandler();
if (handler.get()) {
CefRefPtr<CefDragDataImpl> drag_data(new CefDragDataImpl(drop_data));
drag_data->SetReadOnly(true);
base::MessageLoop::ScopedNestableTaskAllower allow(
base::MessageLoop::current());
handled = handler->StartDragging(
browser.get(),
drag_data.get(),
static_cast<CefRenderHandler::DragOperationsMask>(allowed_ops),
event_info.event_location.x(),
event_info.event_location.y());
if (browser.get()) {
browser->StartDragging(drop_data, allowed_ops, image, image_offset,
event_info, source_rwh);
} else if (web_contents_) {
web_contents_->SystemDragEnded(source_rwh);
}
if (!handled && web_contents_)
web_contents_->SystemDragEnded();
}
void CefWebContentsViewOSR::UpdateDragCursor(
@ -261,16 +250,10 @@ void CefWebContentsViewOSR::UpdateDragCursor(
}
CefRefPtr<CefBrowserHostImpl> browser;
CefRefPtr<CefRenderHandler> handler;
CefRenderWidgetHostViewOSR* view =
static_cast<CefRenderWidgetHostViewOSR*>(view_);
if (view)
browser = view->browser_impl();
if (browser.get())
handler = browser->GetClient()->GetRenderHandler();
if (handler.get()) {
handler->UpdateDragCursor(
browser.get(),
static_cast<CefRenderHandler::DragOperation>(operation));
}
browser->UpdateDragCursor(operation);
}

3
libcef/browser/osr/web_contents_view_osr.h
View File

@ -66,7 +66,8 @@ class CefWebContentsViewOSR : public content::WebContentsView,
blink::WebDragOperationsMask allowed_ops,
const gfx::ImageSkia& image,
const gfx::Vector2d& image_offset,
const content::DragEventSourceInfo& event_info) override;
const content::DragEventSourceInfo& event_info,
content::RenderWidgetHostImpl* source_rwh) override;
void UpdateDragCursor(blink::WebDragOperation operation) override;
private:

32
libcef/browser/plugins/plugin_info_message_filter.cc
View File

@ -20,6 +20,7 @@
#include "build/build_config.h"
#include "chrome/browser/plugins/plugin_finder.h"
#include "chrome/browser/plugins/plugins_field_trial.h"
#include "chrome/common/features.h"
#include "chrome/common/pref_names.h"
#include "components/content_settings/core/browser/content_settings_utils.h"
#include "content/public/browser/browser_context.h"
@ -60,18 +61,18 @@ bool ShouldUseJavaScriptSettingForPlugin(const WebPluginInfo& plugin) {
return true;
#endif
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
// Treat CDM invocations like JavaScript.
if (plugin.name == base::ASCIIToUTF16(kWidevineCdmDisplayName)) {
DCHECK(plugin.type == WebPluginInfo::PLUGIN_TYPE_PEPPER_OUT_OF_PROCESS);
return true;
}
#endif // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#endif // defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
return false;
}
#if defined(ENABLE_PEPPER_CDMS)
#if BUILDFLAG(ENABLE_PEPPER_CDMS)
enum PluginAvailabilityStatusForUMA {
PLUGIN_NOT_REGISTERED,
@ -92,14 +93,14 @@ static void SendPluginAvailabilityUMA(const std::string& mime_type,
#endif // defined(WIDEVINE_CDM_AVAILABLE)
}
#endif // defined(ENABLE_PEPPER_CDMS)
#endif // BUILDFLAG(ENABLE_PEPPER_CDMS)
void ReportMetrics(const std::string& mime_type,
const GURL& url,
const url::Origin& main_frame_origin) {
}
#if defined(ENABLE_EXTENSIONS)
#if BUILDFLAG(ENABLE_EXTENSIONS)
// Returns whether a request from a plugin to load |resource| from a renderer
// with process id |process_id| is a request for an internal resource by an app
// listed in |accessible_resources| in its manifest.
@ -129,7 +130,7 @@ bool IsPluginLoadingAccessibleResourceInWebView(
return renderer_state->GetOwnerInfo(process_id, nullptr, &owner_extension) &&
owner_extension == extension_id;
}
#endif // defined(ENABLE_EXTENSIONS)
#endif // BUILDFLAG(ENABLE_EXTENSIONS)
} // namespace
@ -139,7 +140,7 @@ CefPluginInfoMessageFilter::Context::Context(
: render_process_id_(render_process_id),
resource_context_(profile->GetResourceContext()),
host_content_settings_map_(profile->GetHostContentSettingsMap()) {
#if defined(ENABLE_EXTENSIONS)
#if BUILDFLAG(ENABLE_EXTENSIONS)
if (extensions::ExtensionsEnabled())
extension_registry_ = extensions::ExtensionRegistry::Get(profile);
#endif
@ -174,7 +175,7 @@ bool CefPluginInfoMessageFilter::OnMessageReceived(
IPC_BEGIN_MESSAGE_MAP(CefPluginInfoMessageFilter, message)
IPC_MESSAGE_HANDLER_DELAY_REPLY(CefViewHostMsg_GetPluginInfo,
OnGetPluginInfo)
#if defined(ENABLE_PEPPER_CDMS)
#if BUILDFLAG(ENABLE_PEPPER_CDMS)
IPC_MESSAGE_HANDLER(
CefViewHostMsg_IsInternalPluginAvailableForMimeType,
OnIsInternalPluginAvailableForMimeType)
@ -249,7 +250,7 @@ void CefPluginInfoMessageFilter::PluginsLoaded(
}
}
#if defined(ENABLE_PEPPER_CDMS)
#if BUILDFLAG(ENABLE_PEPPER_CDMS)
void CefPluginInfoMessageFilter::OnIsInternalPluginAvailableForMimeType(
const std::string& mime_type,
@ -285,7 +286,7 @@ void CefPluginInfoMessageFilter::OnIsInternalPluginAvailableForMimeType(
mime_type, is_plugin_disabled ? PLUGIN_DISABLED : PLUGIN_NOT_REGISTERED);
}
#endif // defined(ENABLE_PEPPER_CDMS)
#endif // BUILDFLAG(ENABLE_PEPPER_CDMS)
void CefPluginInfoMessageFilter::Context::DecidePluginStatus(
const GetPluginInfo_Params& params,
@ -312,12 +313,13 @@ void CefPluginInfoMessageFilter::Context::DecidePluginStatus(
// TODO(tommycli): Remove once we deprecate the plugin ASK policy.
bool legacy_ask_user = plugin_setting == CONTENT_SETTING_ASK;
plugin_setting = PluginsFieldTrial::EffectiveContentSetting(
CONTENT_SETTINGS_TYPE_PLUGINS, plugin_setting);
host_content_settings_map_, CONTENT_SETTINGS_TYPE_PLUGINS,
plugin_setting);
DCHECK(plugin_setting != CONTENT_SETTING_DEFAULT);
DCHECK(plugin_setting != CONTENT_SETTING_ASK);
#if defined(ENABLE_PLUGIN_INSTALLATION)
#if BUILDFLAG(ENABLE_PLUGIN_INSTALLATION)
// Check if the plugin is outdated.
if (plugin_status == PluginMetadata::SECURITY_STATUS_OUT_OF_DATE &&
!allow_outdated_plugins_.GetValue()) {
@ -339,7 +341,7 @@ void CefPluginInfoMessageFilter::Context::DecidePluginStatus(
return;
}
#if defined(ENABLE_EXTENSIONS)
#if BUILDFLAG(ENABLE_EXTENSIONS)
// If an app has explicitly made internal resources available by listing them
// in |accessible_resources| in the manifest, then allow them to be loaded by
// plugins inside a guest-view.
@ -350,7 +352,7 @@ void CefPluginInfoMessageFilter::Context::DecidePluginStatus(
extension_registry_, render_process_id_, params.url)) {
plugin_setting = CONTENT_SETTING_ALLOW;
}
#endif // defined(ENABLE_EXTENSIONS)
#endif // BUILDFLAG(ENABLE_EXTENSIONS)
if (plugin_setting == CONTENT_SETTING_DETECT_IMPORTANT_CONTENT) {
*status = CefViewHostMsg_GetPluginInfo_Status::kPlayImportantContent;
@ -362,7 +364,7 @@ void CefPluginInfoMessageFilter::Context::DecidePluginStatus(
: CefViewHostMsg_GetPluginInfo_Status::kBlocked;
}
#if defined(ENABLE_EXTENSIONS)
#if BUILDFLAG(ENABLE_EXTENSIONS)
// Allow an embedder of <webview> to block a plugin from being loaded inside
// the guest. In order to do this, set the status to 'Unauthorized' here,
// and update the status as appropriate depending on the response from the

6
libcef/browser/plugins/plugin_info_message_filter.h
View File

@ -18,6 +18,8 @@
#include "components/content_settings/core/common/content_settings.h"
#include "components/prefs/pref_member.h"
#include "content/public/browser/browser_message_filter.h"
#include "extensions/features/features.h"
#include "ppapi/features/features.h"
class CefBrowserContext;
class CefRequestContextHandler;
@ -74,7 +76,7 @@ class CefPluginInfoMessageFilter : public content::BrowserMessageFilter {
private:
int render_process_id_;
content::ResourceContext* resource_context_;
#if defined(ENABLE_EXTENSIONS)
#if BUILDFLAG(ENABLE_EXTENSIONS)
extensions::ExtensionRegistry* extension_registry_;
#endif
const HostContentSettingsMap* host_content_settings_map_;
@ -109,7 +111,7 @@ class CefPluginInfoMessageFilter : public content::BrowserMessageFilter {
IPC::Message* reply_msg,
const std::vector<content::WebPluginInfo>& plugins);
#if defined(ENABLE_PEPPER_CDMS)
#if BUILDFLAG(ENABLE_PEPPER_CDMS)
// Returns whether any internal plugin supporting |mime_type| is registered
// and enabled. Does not determine whether the plugin can actually be
// instantiated (e.g. whether it has all its dependencies).

12
libcef/browser/prefs/browser_prefs.cc
View File

@ -14,7 +14,7 @@
#include "base/strings/string_number_conversions.h"
#include "base/values.h"
#include "chrome/browser/net/prediction_options.h"
#include "chrome/browser/prefs/command_line_pref_store.h"
#include "chrome/browser/prefs/chrome_command_line_pref_store.h"
#include "chrome/browser/supervised_user/supervised_user_pref_store.h"
#include "chrome/browser/supervised_user/supervised_user_settings_service.h"
#include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
@ -33,8 +33,8 @@
#include "components/proxy_config/pref_proxy_config_tracker_impl.h"
#include "components/proxy_config/proxy_config_dictionary.h"
#include "components/spellcheck/browser/pref_names.h"
#include "components/syncable_prefs/pref_service_syncable.h"
#include "components/syncable_prefs/pref_service_syncable_factory.h"
#include "components/sync_preferences/pref_service_syncable.h"
#include "components/sync_preferences/pref_service_syncable_factory.h"
#include "components/update_client/update_client.h"
#include "content/public/browser/browser_thread.h"
#include "extensions/browser/extension_prefs.h"
@ -102,13 +102,13 @@ std::unique_ptr<PrefService> CreatePrefService(
// Use of PrefServiceSyncable is required by Chrome code such as
// HostContentSettingsMapFactory that calls PrefServiceSyncableFromProfile.
syncable_prefs::PrefServiceSyncableFactory factory;
sync_preferences::PrefServiceSyncableFactory factory;
// Used to store command-line preferences, most of which will be evaluated in
// the CommandLinePrefStore constructor. Preferences set in this manner cannot
// be overridden by the user.
scoped_refptr<CommandLinePrefStore> command_line_pref_store(
new CommandLinePrefStore(command_line));
scoped_refptr<ChromeCommandLinePrefStore> command_line_pref_store(
new ChromeCommandLinePrefStore(command_line));
renderer_prefs::SetCommandLinePrefDefaults(command_line_pref_store.get());
factory.set_command_line_prefs(command_line_pref_store);

5
libcef/browser/prefs/renderer_prefs.cc
View File

@ -20,10 +20,10 @@
#include "chrome/browser/defaults.h"
#include "chrome/browser/extensions/extension_webkit_preferences.h"
#include "chrome/browser/font_family_cache.h"
#include "chrome/browser/prefs/command_line_pref_store.h"
#include "chrome/browser/ui/prefs/prefs_tab_helper.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "components/prefs/command_line_pref_store.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/pref_store.h"
#include "components/pref_registry/pref_registry_syncable.h"
@ -52,8 +52,6 @@ void SetDefaultPrefs(content::WebPreferences& web) {
!command_line->HasSwitch(switches::kDisableJavascriptCloseWindows);
web.javascript_can_access_clipboard =
!command_line->HasSwitch(switches::kDisableJavascriptAccessClipboard);
web.caret_browsing_enabled =
command_line->HasSwitch(switches::kEnableCaretBrowsing);
web.allow_universal_access_from_file_urls =
command_line->HasSwitch(switches::kAllowUniversalAccessFromFileUrls);
web.shrinks_standalone_images_to_fit =
@ -247,7 +245,6 @@ void SetCefPrefs(const CefBrowserSettings& cef,
SET_STATE(cef.javascript_access_clipboard,
web.javascript_can_access_clipboard);
SET_STATE(cef.javascript_dom_paste, web.dom_paste_enabled);
SET_STATE(cef.caret_browsing, web.caret_browsing_enabled);
SET_STATE(cef.plugins, web.plugins_enabled);
SET_STATE(cef.universal_access_from_file_urls,
web.allow_universal_access_from_file_urls);

145
libcef/browser/printing/print_view_manager.cc
View File

@ -5,20 +5,20 @@
#include "include/internal/cef_types_wrappers.h"
#include "libcef/browser/printing/print_view_manager.h"
#include <stdint.h>
#include <map>
#include <utility>
#include "base/bind.h"
#include "base/lazy_instance.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted_memory.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/printing/print_job_manager.h"
#include "chrome/browser/printing/print_preview_dialog_controller.h"
#include "chrome/browser/printing/printer_query.h"
#include "components/printing/common/print_messages.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/web_contents.h"
#include "printing/pdf_metafile_skia.h"
@ -47,6 +47,7 @@ void FillInDictionaryFromPdfPrintSettings(
print_settings.SetInteger(kSettingCopies, 1);
print_settings.SetBoolean(kSettingCollate, false);
print_settings.SetString(kSettingDeviceName, "");
print_settings.SetInteger(kSettingScaleFactor, 100);
print_settings.SetBoolean(kSettingGenerateDraftData, false);
print_settings.SetBoolean(kSettingPreviewModifiable, false);
@ -119,9 +120,9 @@ void StopWorker(int document_cookie) {
}
scoped_refptr<base::RefCountedBytes>
GetDataFromHandle(base::SharedMemoryHandle handle, uint32_t data_size) {
std::unique_ptr<base::SharedMemory> shared_buf(
new base::SharedMemory(handle, true));
GetDataFromHandle(base::SharedMemoryHandle handle, uint32_t data_size) {
std::unique_ptr<base::SharedMemory> shared_buf =
base::MakeUnique<base::SharedMemory>(handle, true);
if (!shared_buf->Map(data_size)) {
NOTREACHED();
@ -156,6 +157,13 @@ void SavePdfFile(scoped_refptr<base::RefCountedBytes> data,
} // namespace
struct CefPrintViewManager::PdfPrintState {
content::RenderFrameHost* printing_rfh_ = nullptr;
base::FilePath output_path_;
base::DictionaryValue settings_;
PdfPrintCallback callback_;
};
CefPrintViewManager::CefPrintViewManager(content::WebContents* web_contents)
: CefPrintViewManagerBase(web_contents) {
}
@ -164,15 +172,62 @@ CefPrintViewManager::~CefPrintViewManager() {
TerminatePdfPrintJob();
}
#if defined(ENABLE_BASIC_PRINTING)
bool CefPrintViewManager::PrintForSystemDialogNow() {
return PrintNowInternal(new PrintMsg_PrintForSystemDialog(routing_id()));
}
#endif // ENABLE_BASIC_PRINTING
bool CefPrintViewManager::PrintToPDF(content::RenderFrameHost* rfh,
const base::FilePath& path,
const CefPdfPrintSettings& settings,
const PdfPrintCallback& callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
bool CefPrintViewManager::OnMessageReceived(const IPC::Message& message) {
// Don't start print again while printing is currently in progress.
if (pdf_print_state_)
return false;
// Don't print interstitials or crashed tabs.
if (!web_contents() || web_contents()->ShowingInterstitialPage() ||
web_contents()->IsCrashed()) {
return false;
}
pdf_print_state_.reset(new PdfPrintState);
pdf_print_state_->printing_rfh_ = rfh;
pdf_print_state_->output_path_ = path;
pdf_print_state_->callback_ = callback;
FillInDictionaryFromPdfPrintSettings(settings,
++next_pdf_request_id_,
pdf_print_state_->settings_);
rfh->Send(new PrintMsg_InitiatePrintPreview(rfh->GetRoutingID(),
!!settings.selection_only));
return true;
}
void CefPrintViewManager::RenderFrameDeleted(
content::RenderFrameHost* render_frame_host) {
if (pdf_print_state_ &&
render_frame_host == pdf_print_state_->printing_rfh_) {
TerminatePdfPrintJob();
}
CefPrintViewManagerBase::RenderFrameDeleted(render_frame_host);
}
void CefPrintViewManager::NavigationStopped() {
TerminatePdfPrintJob();
CefPrintViewManagerBase::NavigationStopped();
}
void CefPrintViewManager::RenderProcessGone(base::TerminationStatus status) {
TerminatePdfPrintJob();
CefPrintViewManagerBase::RenderProcessGone(status);
}
bool CefPrintViewManager::OnMessageReceived(
const IPC::Message& message,
content::RenderFrameHost* render_frame_host) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(CefPrintViewManager, message)
IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(CefPrintViewManager, message,
render_frame_host)
IPC_MESSAGE_HANDLER(PrintHostMsg_DidShowPrintDialog, OnDidShowPrintDialog)
IPC_MESSAGE_HANDLER(PrintHostMsg_RequestPrintPreview,
OnRequestPrintPreview)
@ -181,48 +236,22 @@ bool CefPrintViewManager::OnMessageReceived(const IPC::Message& message) {
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled || CefPrintViewManagerBase::OnMessageReceived(message);
return handled ||
CefPrintViewManagerBase::OnMessageReceived(message, render_frame_host);
}
void CefPrintViewManager::NavigationStopped() {
CefPrintViewManagerBase::NavigationStopped();
TerminatePdfPrintJob();
}
void CefPrintViewManager::RenderProcessGone(base::TerminationStatus status) {
CefPrintViewManagerBase::RenderProcessGone(status);
TerminatePdfPrintJob();
}
void CefPrintViewManager::PrintToPDF(const base::FilePath& path,
const CefPdfPrintSettings& settings,
const PdfPrintCallback& callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (!web_contents() || pdf_print_settings_)
return;
pdf_output_path_ = path;
pdf_print_callback_ = callback;
pdf_print_settings_.reset(new base::DictionaryValue);
FillInDictionaryFromPdfPrintSettings(settings,
++next_pdf_request_id_,
*pdf_print_settings_);
Send(new PrintMsg_InitiatePrintPreview(routing_id(),
!!settings.selection_only));
}
void CefPrintViewManager::OnDidShowPrintDialog() {
void CefPrintViewManager::OnDidShowPrintDialog(content::RenderFrameHost* rfh) {
}
void CefPrintViewManager::OnRequestPrintPreview(
const PrintHostMsg_RequestPrintPreview_Params&) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (!web_contents() || !pdf_print_settings_)
if (!pdf_print_state_)
return;
Send(new PrintMsg_PrintPreview(routing_id(), *pdf_print_settings_));
pdf_print_state_->printing_rfh_->Send(new PrintMsg_PrintPreview(
pdf_print_state_->printing_rfh_->GetRoutingID(),
pdf_print_state_->settings_));
}
void CefPrintViewManager::OnMetafileReadyForPrinting(
@ -230,6 +259,9 @@ void CefPrintViewManager::OnMetafileReadyForPrinting(
DCHECK_CURRENTLY_ON(BrowserThread::UI);
StopWorker(params.document_cookie);
if (!pdf_print_state_)
return;
scoped_refptr<base::RefCountedBytes> data_bytes =
GetDataFromHandle(params.metafile_data_handle, params.data_size);
if (!data_bytes || !data_bytes->size()) {
@ -237,37 +269,32 @@ void CefPrintViewManager::OnMetafileReadyForPrinting(
return;
}
base::FilePath pdf_output_path = pdf_output_path_;
PdfPrintCallback pdf_print_callback = pdf_print_callback_;
const base::FilePath output_path = pdf_print_state_->output_path_;
const PdfPrintCallback print_callback = pdf_print_state_->callback_;
// Reset state information.
pdf_output_path_.clear();
pdf_print_callback_.Reset();
pdf_print_settings_.reset();
pdf_print_state_.reset();
// Save the PDF file to disk and then execute the callback.
BrowserThread::PostTask(BrowserThread::FILE,
FROM_HERE,
base::Bind(&SavePdfFile, data_bytes, pdf_output_path,
pdf_print_callback));
base::Bind(&SavePdfFile, data_bytes, output_path, print_callback));
}
void CefPrintViewManager::TerminatePdfPrintJob() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (!pdf_print_settings_.get())
if (!pdf_print_state_)
return;
if (!pdf_print_callback_.is_null()) {
if (!pdf_print_state_->callback_.is_null()) {
// Execute the callback.
BrowserThread::PostTask(BrowserThread::UI,
FROM_HERE,
base::Bind(pdf_print_callback_, false));
base::Bind(pdf_print_state_->callback_, false));
}
// Reset state information.
pdf_output_path_.clear();
pdf_print_callback_.Reset();
pdf_print_settings_.reset();
pdf_print_state_.reset();
}
} // namespace printing

39
libcef/browser/printing/print_view_manager.h
View File

@ -10,13 +10,14 @@
#include "base/macros.h"
#include "content/public/browser/web_contents_user_data.h"
struct PrintHostMsg_DidPreviewDocument_Params;
struct PrintHostMsg_RequestPrintPreview_Params;
namespace content {
class RenderFrameHost;
class RenderProcessHost;
}
struct PrintHostMsg_DidPreviewDocument_Params;
struct PrintHostMsg_RequestPrintPreview_Params;
namespace printing {
// Manages the print commands for a WebContents.
@ -26,35 +27,28 @@ class CefPrintViewManager :
public:
~CefPrintViewManager() override;
#if defined(ENABLE_BASIC_PRINTING)
// Same as PrintNow(), but for the case where a user prints with the system
// dialog from print preview.
bool PrintForSystemDialogNow();
#endif // ENABLE_BASIC_PRINTING
// content::WebContentsObserver implementation.
bool OnMessageReceived(const IPC::Message& message) override;
// content::WebContentsObserver implementation.
// Cancels the print job.
void NavigationStopped() override;
// Terminates or cancels the print job if one was pending.
void RenderProcessGone(base::TerminationStatus status) override;
// Callback executed on PDF printing completion.
typedef base::Callback<void(bool /*ok*/)> PdfPrintCallback;
// Print the current document to a PDF file. Execute |callback| on completion.
void PrintToPDF(const base::FilePath& path,
bool PrintToPDF(content::RenderFrameHost* rfh,
const base::FilePath& path,
const CefPdfPrintSettings& settings,
const PdfPrintCallback& callback);
// content::WebContentsObserver implementation.
void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
void NavigationStopped() override;
void RenderProcessGone(base::TerminationStatus status) override;
bool OnMessageReceived(const IPC::Message& message,
content::RenderFrameHost* render_frame_host) override;
private:
explicit CefPrintViewManager(content::WebContents* web_contents);
friend class content::WebContentsUserData<CefPrintViewManager>;
// IPC Message handlers.
void OnDidShowPrintDialog();
void OnDidShowPrintDialog(content::RenderFrameHost* rfh);
void OnRequestPrintPreview(const PrintHostMsg_RequestPrintPreview_Params&);
void OnMetafileReadyForPrinting(
const PrintHostMsg_DidPreviewDocument_Params&);
@ -63,9 +57,8 @@ class CefPrintViewManager :
// Used for printing to PDF. Only accessed on the browser process UI thread.
int next_pdf_request_id_ = -1;
base::FilePath pdf_output_path_;
std::unique_ptr<base::DictionaryValue> pdf_print_settings_;
PdfPrintCallback pdf_print_callback_;
struct PdfPrintState;
std::unique_ptr<PdfPrintState> pdf_print_state_;
DISALLOW_COPY_AND_ASSIGN(CefPrintViewManager);
};

145
libcef/browser/printing/print_view_manager_base.cc
View File

@ -4,23 +4,25 @@
#include "libcef/browser/printing/print_view_manager_base.h"
#include <memory>
#include <utility>
#include "libcef/browser/content_browser_client.h"
#include "base/auto_reset.h"
#include "base/bind.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/timer/timer.h"
#include "build/build_config.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/printing/print_job.h"
#include "chrome/browser/printing/print_job_manager.h"
#include "chrome/browser/printing/printer_query.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/pref_names.h"
#include "chrome/grit/generated_resources.h"
#include "components/prefs/pref_service.h"
@ -29,8 +31,10 @@
#include "content/public/browser/notification_details.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/notification_source.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents.h"
#include "printing/features/features.h"
#include "printing/pdf_metafile_skia.h"
#include "printing/printed_document.h"
#include "ui/base/l10n/l10n_util.h"
@ -48,6 +52,7 @@ namespace printing {
CefPrintViewManagerBase::CefPrintViewManagerBase(
content::WebContents* web_contents)
: PrintManager(web_contents),
printing_rfh_(nullptr),
printing_succeeded_(false),
inside_inner_message_loop_(false),
#if !defined(OS_MACOSX)
@ -55,13 +60,11 @@ CefPrintViewManagerBase::CefPrintViewManagerBase(
#endif
queue_(g_browser_process->print_job_manager()->queue()) {
DCHECK(queue_.get());
PrefService* pref_service =
static_cast<CefBrowserContext*>(web_contents->GetBrowserContext())->
GetPrefs();
Profile* profile =
Profile::FromBrowserContext(web_contents->GetBrowserContext());
printing_enabled_.Init(
prefs::kPrintingEnabled,
pref_service,
base::Bind(&CefPrintViewManagerBase::UpdateScriptedPrintingBlocked,
prefs::kPrintingEnabled, profile->GetPrefs(),
base::Bind(&CefPrintViewManagerBase::UpdatePrintingEnabled,
base::Unretained(this)));
}
@ -70,16 +73,20 @@ CefPrintViewManagerBase::~CefPrintViewManagerBase() {
DisconnectFromCurrentPrintJob();
}
#if defined(ENABLE_BASIC_PRINTING)
bool CefPrintViewManagerBase::PrintNow() {
return PrintNowInternal(new PrintMsg_PrintPages(routing_id()));
#if BUILDFLAG(ENABLE_BASIC_PRINTING)
bool CefPrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh) {
DisconnectFromCurrentPrintJob();
SetPrintingRFH(rfh);
int32_t id = rfh->GetRoutingID();
return PrintNowInternal(rfh, base::MakeUnique<PrintMsg_PrintPages>(id));
}
#endif
void CefPrintViewManagerBase::UpdateScriptedPrintingBlocked() {
Send(new PrintMsg_SetScriptedPrintingBlocked(
routing_id(),
!printing_enabled_.GetValue()));
void CefPrintViewManagerBase::UpdatePrintingEnabled() {
web_contents()->ForEachFrame(
base::Bind(&CefPrintViewManagerBase::SendPrintingEnabled,
base::Unretained(this), printing_enabled_.GetValue()));
}
void CefPrintViewManagerBase::NavigationStopped() {
@ -87,23 +94,6 @@ void CefPrintViewManagerBase::NavigationStopped() {
TerminatePrintJob(true);
}
void CefPrintViewManagerBase::RenderProcessGone(
base::TerminationStatus status) {
PrintManager::RenderProcessGone(status);
ReleasePrinterQuery();
if (!print_job_.get())
return;
scoped_refptr<PrintedDocument> document(print_job_->document());
if (document.get()) {
// If IsComplete() returns false, the document isn't completely rendered.
// Since our renderer is gone, there's nothing to do, cancel it. Otherwise,
// the print job may finish without problem.
TerminatePrintJob(!document->IsComplete());
}
}
base::string16 CefPrintViewManagerBase::RenderSourceName() {
base::string16 name(web_contents()->GetTitle());
if (name.empty())
@ -173,24 +163,24 @@ void CefPrintViewManagerBase::OnDidPrintPage(
#if defined(OS_WIN)
print_job_->AppendPrintedPage(params.page_number);
if (metafile_must_be_valid) {
// TODO(thestig): Figure out why rendering text with GDI results in random
// missing characters for some users. https://crbug.com/658606
bool print_text_with_gdi =
document->settings().print_text_with_gdi() &&
!document->settings().printer_is_xps() &&
!base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kDisableGDITextPrinting);
switches::GDITextPrintingEnabled();
scoped_refptr<base::RefCountedBytes> bytes = new base::RefCountedBytes(
reinterpret_cast<const unsigned char*>(shared_buf->memory()),
params.data_size);
document->DebugDumpData(bytes.get(), FILE_PATH_LITERAL(".pdf"));
print_job_->StartPdfToEmfConversion(
bytes, params.page_size, params.content_area, print_text_with_gdi);
bytes, params.page_size, params.content_area,
print_text_with_gdi);
}
#else
// Update the rendered document. It will send notifications to the listener.
document->SetPage(params.page_number,
std::move(metafile),
params.page_size,
document->SetPage(params.page_number, std::move(metafile), params.page_size,
params.content_area);
ShouldQuitFromInnerMessageLoop();
@ -212,18 +202,43 @@ void CefPrintViewManagerBase::OnShowInvalidPrinterSettingsError() {
}
void CefPrintViewManagerBase::DidStartLoading() {
UpdateScriptedPrintingBlocked();
UpdatePrintingEnabled();
}
bool CefPrintViewManagerBase::OnMessageReceived(const IPC::Message& message) {
void CefPrintViewManagerBase::RenderFrameDeleted(
content::RenderFrameHost* render_frame_host) {
// Terminates or cancels the print job if one was pending.
if (render_frame_host != printing_rfh_)
return;
printing_rfh_ = nullptr;
PrintManager::PrintingRenderFrameDeleted();
ReleasePrinterQuery();
if (!print_job_.get())
return;
scoped_refptr<PrintedDocument> document(print_job_->document());
if (document.get()) {
// If IsComplete() returns false, the document isn't completely rendered.
// Since our renderer is gone, there's nothing to do, cancel it. Otherwise,
// the print job may finish without problem.
TerminatePrintJob(!document->IsComplete());
}
}
bool CefPrintViewManagerBase::OnMessageReceived(
const IPC::Message& message,
content::RenderFrameHost* render_frame_host) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(CefPrintViewManagerBase, message)
IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage)
IPC_MESSAGE_HANDLER(PrintHostMsg_ShowInvalidPrinterSettingsError,
OnShowInvalidPrinterSettingsError);
OnShowInvalidPrinterSettingsError)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled || PrintManager::OnMessageReceived(message);
return handled || PrintManager::OnMessageReceived(message, render_frame_host);
}
void CefPrintViewManagerBase::Observe(
@ -335,7 +350,7 @@ void CefPrintViewManagerBase::ShouldQuitFromInnerMessageLoop() {
bool CefPrintViewManagerBase::CreateNewPrintJob(PrintJobWorkerOwner* job) {
DCHECK(!inside_inner_message_loop_);
// Disconnect the current print_job_.
// Disconnect the current |print_job_|.
DisconnectFromCurrentPrintJob();
// We can't print if there is no renderer.
@ -380,12 +395,6 @@ void CefPrintViewManagerBase::DisconnectFromCurrentPrintJob() {
#endif
}
void CefPrintViewManagerBase::PrintingDone(bool success) {
if (!print_job_.get())
return;
Send(new PrintMsg_PrintingDone(routing_id(), success));
}
void CefPrintViewManagerBase::TerminatePrintJob(bool cancel) {
if (!print_job_.get())
return;
@ -407,16 +416,23 @@ void CefPrintViewManagerBase::TerminatePrintJob(bool cancel) {
}
void CefPrintViewManagerBase::ReleasePrintJob() {
content::RenderFrameHost* rfh = printing_rfh_;
printing_rfh_ = nullptr;
if (!print_job_.get())
return;
PrintingDone(printing_succeeded_);
if (rfh) {
auto msg = base::MakeUnique<PrintMsg_PrintingDone>(rfh->GetRoutingID(),
printing_succeeded_);
rfh->Send(msg.release());
}
registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
content::Source<PrintJob>(print_job_.get()));
print_job_->DisconnectSource();
// Don't close the worker thread.
print_job_ = NULL;
print_job_ = nullptr;
}
bool CefPrintViewManagerBase::RunInnerMessageLoop() {
@ -485,14 +501,18 @@ bool CefPrintViewManagerBase::OpportunisticallyCreatePrintJob(int cookie) {
return true;
}
bool CefPrintViewManagerBase::PrintNowInternal(IPC::Message* message) {
bool CefPrintViewManagerBase::PrintNowInternal(
content::RenderFrameHost* rfh,
std::unique_ptr<IPC::Message> message) {
// Don't print / print preview interstitials or crashed tabs.
if (web_contents()->ShowingInterstitialPage() ||
web_contents()->IsCrashed()) {
delete message;
if (web_contents()->ShowingInterstitialPage() || web_contents()->IsCrashed())
return false;
}
return Send(message);
return rfh->Send(message.release());
}
void CefPrintViewManagerBase::SetPrintingRFH(content::RenderFrameHost* rfh) {
DCHECK(!printing_rfh_);
printing_rfh_ = rfh;
}
void CefPrintViewManagerBase::ReleasePrinterQuery() {
@ -502,13 +522,12 @@ void CefPrintViewManagerBase::ReleasePrinterQuery() {
int cookie = cookie_;
cookie_ = 0;
printing::PrintJobManager* print_job_manager =
g_browser_process->print_job_manager();
PrintJobManager* print_job_manager = g_browser_process->print_job_manager();
// May be NULL in tests.
if (!print_job_manager)
return;
scoped_refptr<printing::PrinterQuery> printer_query;
scoped_refptr<PrinterQuery> printer_query;
printer_query = queue_->PopPrinterQuery(cookie);
if (!printer_query.get())
return;
@ -517,4 +536,10 @@ void CefPrintViewManagerBase::ReleasePrinterQuery() {
base::Bind(&PrinterQuery::StopWorker, printer_query));
}
void CefPrintViewManagerBase::SendPrintingEnabled(
bool enabled,
content::RenderFrameHost* rfh) {
rfh->Send(new PrintMsg_SetPrintingEnabled(rfh->GetRoutingID(), enabled));
}
} // namespace printing

38
libcef/browser/printing/print_view_manager_base.h
View File

@ -5,6 +5,8 @@
#ifndef CEF_LIBCEF_BROWSER_PRINTING_PRINT_VIEW_MANAGER_BASE_H_
#define CEF_LIBCEF_BROWSER_PRINTING_PRINT_VIEW_MANAGER_BASE_H_
#include <memory>
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/strings/string16.h"
@ -13,12 +15,13 @@
#include "components/printing/browser/print_manager.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "printing/features/features.h"
#include "printing/printed_pages_source.h"
struct PrintHostMsg_DidPrintPage_Params;
namespace content {
class RenderViewHost;
class RenderFrameHost;
}
namespace printing {
@ -36,15 +39,15 @@ class CefPrintViewManagerBase : public content::NotificationObserver,
public:
~CefPrintViewManagerBase() override;
#if defined(ENABLE_BASIC_PRINTING)
#if BUILDFLAG(ENABLE_BASIC_PRINTING)
// Prints the current document immediately. Since the rendering is
// asynchronous, the actual printing will not be completed on the return of
// this function. Returns false if printing is impossible at the moment.
virtual bool PrintNow();
virtual bool PrintNow(content::RenderFrameHost* rfh);
#endif // ENABLE_BASIC_PRINTING
// Whether to block scripted printing for our tab or not.
void UpdateScriptedPrintingBlocked();
// Whether printing is enabled or not.
void UpdatePrintingEnabled();
// PrintedPagesSource implementation.
base::string16 RenderSourceName() override;
@ -53,17 +56,19 @@ class CefPrintViewManagerBase : public content::NotificationObserver,
explicit CefPrintViewManagerBase(content::WebContents* web_contents);
// Helper method for Print*Now().
bool PrintNowInternal(IPC::Message* message);
bool PrintNowInternal(content::RenderFrameHost* rfh,
std::unique_ptr<IPC::Message> message);
void SetPrintingRFH(content::RenderFrameHost* rfh);
// content::WebContentsObserver implementation.
void RenderFrameDeleted(content::RenderFrameHost* render_frame_host) override;
bool OnMessageReceived(const IPC::Message& message,
content::RenderFrameHost* render_frame_host) override;
// Cancels the print job.
void NavigationStopped() override;
// Terminates or cancels the print job if one was pending.
void RenderProcessGone(base::TerminationStatus status) override;
// content::WebContentsObserver implementation.
bool OnMessageReceived(const IPC::Message& message) override;
private:
// content::NotificationObserver implementation.
void Observe(int type,
@ -104,9 +109,6 @@ class CefPrintViewManagerBase : public content::NotificationObserver,
// disconnect from it.
void DisconnectFromCurrentPrintJob();
// Notify that the printing is done.
void PrintingDone(bool success);
// Terminates the print job. No-op if no print job has been created. If
// |cancel| is true, cancel it instead of waiting for the job to finish. Will
// call ReleasePrintJob().
@ -130,8 +132,14 @@ class CefPrintViewManagerBase : public content::NotificationObserver,
// Release the PrinterQuery associated with our |cookie_|.
void ReleasePrinterQuery();
// Helper method for UpdatePrintingEnabled().
void SendPrintingEnabled(bool enabled, content::RenderFrameHost* rfh);
content::NotificationRegistrar registrar_;
// The current RFH that is printing with a system printing dialog.
content::RenderFrameHost* printing_rfh_;
// Manages the low-level talk to the printer.
scoped_refptr<PrintJob> print_job_;

93
libcef/browser/printing/printing_message_filter.cc
View File

@ -4,19 +4,25 @@
#include "libcef/browser/printing/printing_message_filter.h"
#include <memory>
#include <string>
#include <utility>
#include "base/bind.h"
#include "build/build_config.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/printing/print_job_manager.h"
#include "chrome/browser/printing/printer_query.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/pref_names.h"
#include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
#include "components/printing/browser/print_manager_utils.h"
#include "components/printing/common/print_messages.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h"
#include "content/public/common/child_process_host.h"
#include "printing/features/features.h"
#if defined(OS_LINUX)
#include "libcef/browser/printing/print_dialog_linux.h"
@ -26,24 +32,90 @@ using content::BrowserThread;
namespace printing {
CefPrintingMessageFilter::CefPrintingMessageFilter(int render_process_id)
namespace {
// There's a race condition between deletion of the CefPrintingMessageFilter
// object on the UI thread and deletion of the PrefService (owned by Profile)
// on the UI thread. If the PrefService will be deleted first then
// PrefMember::Destroy() must be called from ShutdownOnUIThread() to avoid
// heap-use-after-free on CefPrintingMessageFilter destruction (due to
// ~PrefMember trying to access the already-deleted PrefService).
// ShutdownNotifierFactory makes sure that ShutdownOnUIThread() is called in
// this case.
class ShutdownNotifierFactory
: public BrowserContextKeyedServiceShutdownNotifierFactory {
public:
static ShutdownNotifierFactory* GetInstance();
private:
friend struct base::DefaultLazyInstanceTraits<ShutdownNotifierFactory>;
ShutdownNotifierFactory()
: BrowserContextKeyedServiceShutdownNotifierFactory(
"CefPrintingMessageFilter") {
}
~ShutdownNotifierFactory() override {}
DISALLOW_COPY_AND_ASSIGN(ShutdownNotifierFactory);
};
base::LazyInstance<ShutdownNotifierFactory>::Leaky
g_shutdown_notifier_factory = LAZY_INSTANCE_INITIALIZER;
// static
ShutdownNotifierFactory* ShutdownNotifierFactory::GetInstance() {
return g_shutdown_notifier_factory.Pointer();
}
} // namespace
CefPrintingMessageFilter::CefPrintingMessageFilter(int render_process_id,
Profile* profile)
: content::BrowserMessageFilter(PrintMsgStart),
render_process_id_(render_process_id),
queue_(g_browser_process->print_job_manager()->queue()) {
DCHECK(queue_.get());
DCHECK_CURRENTLY_ON(BrowserThread::UI);
shutdown_notifier_ =
ShutdownNotifierFactory::GetInstance()->Get(profile)->Subscribe(
base::Bind(&CefPrintingMessageFilter::ShutdownOnUIThread,
base::Unretained(this)));
is_printing_enabled_.Init(prefs::kPrintingEnabled, profile->GetPrefs());
is_printing_enabled_.MoveToThread(
content::BrowserThread::GetTaskRunnerForThread(BrowserThread::IO));
}
void CefPrintingMessageFilter::EnsureShutdownNotifierFactoryBuilt() {
ShutdownNotifierFactory::GetInstance();
}
CefPrintingMessageFilter::~CefPrintingMessageFilter() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
}
void CefPrintingMessageFilter::ShutdownOnUIThread() {
is_printing_enabled_.Destroy();
shutdown_notifier_.reset();
}
void CefPrintingMessageFilter::OverrideThreadForMessage(
const IPC::Message& message, BrowserThread::ID* thread) {
#if defined(OS_ANDROID)
if (message.type() == PrintHostMsg_AllocateTempFileForPrinting::ID ||
message.type() == PrintHostMsg_TempFileForPrintingWritten::ID) {
*thread = BrowserThread::UI;
}
#endif
}
void CefPrintingMessageFilter::OnDestruct() const {
BrowserThread::DeleteOnUIThread::Destruct(this);
}
bool CefPrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(CefPrintingMessageFilter, message)
IPC_MESSAGE_HANDLER(PrintHostMsg_IsPrintingEnabled, OnIsPrintingEnabled)
IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_GetDefaultPrintSettings,
OnGetDefaultPrintSettings)
IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
@ -55,11 +127,6 @@ bool CefPrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
return handled;
}
void CefPrintingMessageFilter::OnIsPrintingEnabled(bool* is_enabled) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
*is_enabled = true;
}
void CefPrintingMessageFilter::OnGetDefaultPrintSettings(
IPC::Message* reply_msg) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
@ -70,6 +137,11 @@ void CefPrintingMessageFilter::OnGetDefaultPrintSettings(
#endif
scoped_refptr<PrinterQuery> printer_query;
if (!is_printing_enabled_.GetValue()) {
// Reply with NULL query.
OnGetDefaultPrintSettingsReply(printer_query, reply_msg);
return;
}
printer_query = queue_->PopPrinterQuery(0);
if (!printer_query.get()) {
printer_query =
@ -168,6 +240,11 @@ void CefPrintingMessageFilter::OnUpdatePrintSettings(
std::unique_ptr<base::DictionaryValue> new_settings(job_settings.DeepCopy());
scoped_refptr<PrinterQuery> printer_query;
if (!is_printing_enabled_.GetValue()) {
// Reply with NULL query.
OnUpdatePrintSettingsReply(printer_query, reply_msg);
return;
}
printer_query = queue_->PopPrinterQuery(document_cookie);
if (!printer_query.get()) {
int host_id = render_process_id_;

39
libcef/browser/printing/printing_message_filter.h
View File

@ -7,31 +7,25 @@
#include <stdint.h>
#include <memory>
#include <string>
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "build/build_config.h"
#include "components/keyed_service/core/keyed_service_shutdown_notifier.h"
#include "components/prefs/pref_member.h"
#include "content/public/browser/browser_message_filter.h"
#if defined(OS_WIN)
#include "base/memory/shared_memory.h"
#endif
#include "printing/features/features.h"
struct PrintHostMsg_ScriptedPrint_Params;
class Profile;
namespace base {
class DictionaryValue;
class FilePath;
}
namespace content {
class WebContents;
}
namespace printing {
class PrintJobManager;
class PrintQueriesQueue;
class PrinterQuery;
@ -39,24 +33,23 @@ class PrinterQuery;
// renderer process on the IPC thread.
class CefPrintingMessageFilter : public content::BrowserMessageFilter {
public:
explicit CefPrintingMessageFilter(int render_process_id);
CefPrintingMessageFilter(int render_process_id, Profile* profile);
static void EnsureShutdownNotifierFactoryBuilt();
// content::BrowserMessageFilter methods.
void OverrideThreadForMessage(const IPC::Message& message,
content::BrowserThread::ID* thread) override;
void OnDestruct() const override;
bool OnMessageReceived(const IPC::Message& message) override;
private:
friend class base::DeleteHelper<CefPrintingMessageFilter>;
friend class content::BrowserThread;
~CefPrintingMessageFilter() override;
// GetPrintSettingsForRenderView must be called via PostTask and
// base::Bind. Collapse the settings-specific params into a
// struct to avoid running into issues with too many params
// to base::Bind.
struct GetPrintSettingsForRenderViewParams;
// Checks if printing is enabled.
void OnIsPrintingEnabled(bool* is_enabled);
void ShutdownOnUIThread();
// Get the default print setting.
void OnGetDefaultPrintSettings(IPC::Message* reply_msg);
@ -80,14 +73,20 @@ class CefPrintingMessageFilter : public content::BrowserMessageFilter {
void OnUpdatePrintSettingsReply(scoped_refptr<PrinterQuery> printer_query,
IPC::Message* reply_msg);
// Check to see if print preview has been cancelled.
void OnCheckForCancel(int32_t preview_ui_id,
int preview_request_id,
bool* cancel);
BooleanPrefMember is_printing_enabled_;
const int render_process_id_;
scoped_refptr<PrintQueriesQueue> queue_;
std::unique_ptr<KeyedServiceShutdownNotifier::Subscription>
shutdown_notifier_;
DISALLOW_COPY_AND_ASSIGN(CefPrintingMessageFilter);
};

39
libcef/browser/resource_dispatcher_host_delegate.cc
View File

@ -81,29 +81,12 @@ CefResourceDispatcherHostDelegate::~CefResourceDispatcherHostDelegate() {
bool CefResourceDispatcherHostDelegate::HandleExternalProtocol(
const GURL& url,
int child_id,
const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
bool is_main_frame,
ui::PageTransition page_transition,
bool has_user_gesture,
content::ResourceContext* resource_context) {
if (!CEF_CURRENTLY_ON_UIT()) {
content::ResourceRequestInfo* info) {
CEF_POST_TASK(CEF_UIT,
base::Bind(base::IgnoreResult(&CefResourceDispatcherHostDelegate::
HandleExternalProtocol),
base::Unretained(this), url, child_id, web_contents_getter,
is_main_frame, page_transition, has_user_gesture,
resource_context));
return false;
}
content::WebContents* web_contents = web_contents_getter.Run();
if (web_contents) {
CefRefPtr<CefBrowserHostImpl> browser =
CefBrowserHostImpl::GetBrowserForContents(web_contents);
if (browser.get())
browser->HandleExternalProtocol(url);
}
HandleExternalProtocolOnUIThread),
base::Unretained(this), url,
info->GetWebContentsGetterForRequest()));
return false;
}
@ -218,3 +201,17 @@ std::unique_ptr<net::ClientCertStore>
return static_cast<CefResourceContext*>(resource_context)->
CreateClientCertStore();
}
void CefResourceDispatcherHostDelegate::HandleExternalProtocolOnUIThread(
const GURL& url,
const content::ResourceRequestInfo::WebContentsGetter&
web_contents_getter) {
CEF_REQUIRE_UIT();
content::WebContents* web_contents = web_contents_getter.Run();
if (web_contents) {
CefRefPtr<CefBrowserHostImpl> browser =
CefBrowserHostImpl::GetBrowserForContents(web_contents);
if (browser.get())
browser->HandleExternalProtocol(url);
}
}

13
libcef/browser/resource_dispatcher_host_delegate.h
View File

@ -23,13 +23,7 @@ class CefResourceDispatcherHostDelegate
// ResourceDispatcherHostDelegate methods.
bool HandleExternalProtocol(
const GURL& url,
int child_id,
const content::ResourceRequestInfo::WebContentsGetter&
web_contents_getter,
bool is_main_frame,
ui::PageTransition page_transition,
bool has_user_gesture,
content::ResourceContext* resource_context) override;
content::ResourceRequestInfo* info) override;
bool ShouldInterceptResourceAsStream(net::URLRequest* request,
const base::FilePath& plugin_path,
const std::string& mime_type,
@ -46,6 +40,11 @@ class CefResourceDispatcherHostDelegate
content::ResourceContext* resource_context) override;
private:
void HandleExternalProtocolOnUIThread(
const GURL& url,
const content::ResourceRequestInfo::WebContentsGetter&
web_contents_getter);
struct StreamTargetInfo {
std::string extension_id;
std::string view_id;

4
libcef/browser/storage_partition_proxy.cc
View File

@ -81,6 +81,10 @@ CefStoragePartitionProxy::GetBackgroundSyncContext() {
return parent_->GetBackgroundSyncContext();
}
content::PaymentAppContext* CefStoragePartitionProxy::GetPaymentAppContext() {
return parent_->GetPaymentAppContext();
}
content::BroadcastChannelProvider*
CefStoragePartitionProxy::GetBroadcastChannelProvider() {
return parent_->GetBroadcastChannelProvider();

1
libcef/browser/storage_partition_proxy.h
View File

@ -37,6 +37,7 @@ class CefStoragePartitionProxy : public content::StoragePartition {
content::PlatformNotificationContext* GetPlatformNotificationContext()
override;
content::BackgroundSyncContext* GetBackgroundSyncContext() override;
content::PaymentAppContext* GetPaymentAppContext() override;
content::BroadcastChannelProvider* GetBroadcastChannelProvider() override;
void ClearDataForOrigin(uint32_t remove_mask,
uint32_t quota_storage_remove_mask,

6
libcef/browser/web_plugin_impl.cc
View File

@ -30,7 +30,7 @@ void PluginsCallbackImpl(
}
}
#if !(defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)) || \
#if !(defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)) || \
defined(OS_LINUX)
void DeliverWidevineCdmError(const std::string& error_message,
@ -171,7 +171,7 @@ void CefIsWebPluginUnstable(
void CefRegisterWidevineCdm(const CefString& path,
CefRefPtr<CefRegisterCdmCallback> callback) {
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
#if defined(OS_LINUX)
// Enforce the requirement that CefRegisterWidevineCdm() is called before
// CefInitialize() on Linux. See comments in
@ -187,5 +187,5 @@ void CefRegisterWidevineCdm(const CefString& path,
CefWidevineLoader::GetInstance()->LoadWidevineCdm(path, callback);
#else
DeliverWidevineCdmError("Widevine registration is not supported", callback);
#endif // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#endif // defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
}

3
libcef/common/cef_switches.cc
View File

@ -50,9 +50,6 @@ const char kDisableJavascriptAccessClipboard[] =
// Disable DOM paste via JavaScript execCommand("paste").
const char kDisableJavascriptDomPaste[] = "disable-javascript-dom-paste";
// Enable caret browsing.
const char kEnableCaretBrowsing[] = "enable-caret-browsing";
// Allow universal access from file URLs.
const char kAllowUniversalAccessFromFileUrls[] =
"allow-universal-access-from-files";

1
libcef/common/cef_switches.h
View File

@ -27,7 +27,6 @@ extern const char kDisableJavascriptOpenWindows[];
extern const char kDisableJavascriptCloseWindows[];
extern const char kDisableJavascriptAccessClipboard[];
extern const char kDisableJavascriptDomPaste[];
extern const char kEnableCaretBrowsing[];
extern const char kAllowUniversalAccessFromFileUrls[];
extern const char kDisableImageLoading[];
extern const char kImageShrinkStandaloneToFit[];

2
libcef/common/content_client.cc
View File

@ -206,7 +206,7 @@ void CefContentClient::AddPepperPlugins(
AddPepperFlashFromCommandLine(plugins);
#if defined(OS_LINUX)
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
CefWidevineLoader::AddPepperPlugins(plugins);
#endif
#endif

2
libcef/common/extensions/api/BUILD.gn
View File

@ -2,8 +2,8 @@
# 2014 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.
import("//build/json_schema_api.gni")
import("//tools/json_schema_compiler/json_features.gni")
#import("//tools/json_schema_compiler/json_schema_api.gni")
# TODO(cef): Enable if/when CEF exposes its own Mojo APIs. See README.txt for
# details.

32
libcef/common/extensions/api/README.txt
View File

@ -10,20 +10,22 @@ To add a new extension API implemented only in CEF ***:
API.
2. Add <api>.idl or .json to the 'schema_sources' list in
libcef/common/extensions/api/BUILD.gn. Serialization code will be
generated based on this list in step 5.
3. Add an entry in the libcef/common/extensions/api/_*_features.json files if
necessary [1].
4. Add libcef/browser/extensions/api/<api>/<api>_api.[h|cc] class implementation
generated based on this list in step 4.
3. Add libcef/browser/extensions/api/<api>/<api>_api.[h|cc] class implementation
files and associated entries to the 'libcef_static' target in BUILD.gn.
5. Run the cef_create_projects script and build to generate the
4. Run the cef_create_projects script and build to generate the
cef/libcef/common/extensions/api/<api>.h file and other serialization code
required by the extensions system.
6. Call `<class>::GetInstance();` or `<class>Factory::GetFactoryInstance();` [2]
5. Add an entry in the libcef/common/extensions/api/_*_features.json files if
necessary [1].
6. Add an entry in the libcef/common/extensions/api/*_manifest_overlay.json
files if necessary [2].
7. Call `<class>::GetInstance();` or `<class>Factory::GetFactoryInstance();` [3]
from EnsureBrowserContextKeyedServiceFactoriesBuilt in
libcef/browser/extensions/browser_context_keyed_service_factories.cc.
7. Call `DependsOn(<class>Factory::GetInstance());` from
8. Call `DependsOn(<class>Factory::GetInstance());` from
CefExtensionSystemFactory::CefExtensionSystemFactory in
libcef/browser/extensions/extension_system_factory.cc if necessary [2].
libcef/browser/extensions/extension_system_factory.cc if necessary [3].
*** Note that CEF does not currently expose its own Mojo APIs. Related code is
commented out in:
@ -36,7 +38,7 @@ commented out in:
To add a new extension API implemented in Chrome:
1. Register the API in libcef/browser/extensions/chrome_api_registration.cc
2. Perform steps 3, 6 and 7 above.
2. Perform steps 5 through 8 above.
See https://www.chromium.org/developers/design-documents/mojo for more
information.
@ -46,7 +48,17 @@ information.
additional details. For Chrome extensions this should match the definitions
in the chrome/common/extensions/api/_*_features.json files.
[2] Some Mojo APIs use singleton Factory objects that create a one-to-one
[2] Service Manifest InterfaceProviderSpecs control interfaces exposed between
processes. Mojo interfaces exposed at the frame level are controlled by the
"navigation:frame" dictionary. Those exposed at the process level are
controlled by the "service_manager:connector" dictionary. Failure to specify
this correctly may result in a console error like the following:
InterfaceProviderSpec "navigation:frame" prevented service:
service:content_renderer from binding interface:
mojom::Foo exposed by: service:content_browser
[3] Some Mojo APIs use singleton Factory objects that create a one-to-one
relationship between a service and a BrowserContext. This is used primarily
to control shutdown/destruction order and implementors must explicitly state
which services are depended on. See comments in

14
libcef/common/extensions/api/browser_manifest_overlay.json Normal file
View File

@ -0,0 +1,14 @@
{
"name": "content_browser",
"display_name": "CEF",
"interface_provider_specs": {
"navigation:frame": {
"provides": {
"renderer": [
"extensions::KeepAlive",
"extensions::mime_handler::MimeHandlerService"
]
}
}
}
}

5
libcef/common/extensions/api/renderer_manifest_overlay.json Normal file
View File

@ -0,0 +1,5 @@
{
"display_name": "Chrome Render Process",
"interface_provider_specs": {
}
}

12
libcef/common/extensions/api/utility_manifest_overlay.json Normal file
View File

@ -0,0 +1,12 @@
{
"name": "content_utility",
"interface_provider_specs": {
"service_manager:connector": {
"provides": {
"browser": [
"net::interfaces::ProxyResolverFactory"
]
}
}
}
}

14
libcef/common/extensions/extensions_client.cc
View File

@ -17,10 +17,12 @@
#include "cef/libcef/common/extensions/api/cef_behavior_features.h"
#include "cef/libcef/common/extensions/api/cef_manifest_features.h"
#include "cef/libcef/common/extensions/api/cef_permission_features.h"
#include "chrome/common/extensions/chrome_aliases.h"
#include "chrome/common/extensions/chrome_manifest_handlers.h"
#include "chrome/grit/common_resources.h"
#include "extensions/common/api/generated_schemas.h"
#include "extensions/common/common_manifest_handlers.h"
#include "extensions/common/extensions_aliases.h"
#include "extensions/common/extension_urls.h"
#include "extensions/common/features/api_feature.h"
#include "extensions/common/features/behavior_feature.h"
@ -59,8 +61,10 @@ void CefExtensionsClient::Initialize() {
// TODO(jamescook): Do we need to whitelist any extensions?
// Set up permissions.
PermissionsInfo::GetInstance()->AddProvider(chrome_api_permissions_);
PermissionsInfo::GetInstance()->AddProvider(extensions_api_permissions_);
PermissionsInfo::GetInstance()->AddProvider(chrome_api_permissions_,
GetChromePermissionAliases());
PermissionsInfo::GetInstance()->AddProvider(extensions_api_permissions_,
GetExtensionsPermissionAliases());
}
const PermissionMessageProvider&
@ -177,8 +181,10 @@ std::string CefExtensionsClient::GetWebstoreBaseURL() const {
return extension_urls::kChromeWebstoreBaseURL;
}
std::string CefExtensionsClient::GetWebstoreUpdateURL() const {
return extension_urls::kChromeWebstoreUpdateURL;
const GURL& CefExtensionsClient::GetWebstoreUpdateURL() const {
if (webstore_update_url_.is_empty())
webstore_update_url_ = GURL(extension_urls::GetWebstoreUpdateUrl());
return webstore_update_url_;
}
bool CefExtensionsClient::IsBlacklistUpdateURL(const GURL& url) const {

6
libcef/common/extensions/extensions_client.h
View File

@ -12,6 +12,7 @@
#include "chrome/common/extensions/permissions/chrome_permission_message_provider.h"
#include "extensions/common/extensions_client.h"
#include "extensions/common/permissions/extensions_api_permissions.h"
#include "url/gurl.h"
namespace extensions {
@ -44,7 +45,7 @@ class CefExtensionsClient : public ExtensionsClient {
bool ShouldSuppressFatalErrors() const override;
void RecordDidSuppressFatalError() override;
std::string GetWebstoreBaseURL() const override;
std::string GetWebstoreUpdateURL() const override;
const GURL& GetWebstoreUpdateURL() const override;
bool IsBlacklistUpdateURL(const GURL& url) const override;
private:
@ -54,6 +55,9 @@ class CefExtensionsClient : public ExtensionsClient {
ScriptingWhitelist scripting_whitelist_;
// Mutable to allow caching in a const method.
mutable GURL webstore_update_url_;
DISALLOW_COPY_AND_ASSIGN(CefExtensionsClient);
};

3
libcef/common/net/scheme_registration.cc
View File

@ -7,6 +7,7 @@
#include "libcef/common/content_client.h"
#include "content/public/common/url_constants.h"
#include "net/net_features.h"
#include "extensions/common/constants.h"
#include "url/url_constants.h"
@ -65,7 +66,7 @@ bool IsInternalProtectedScheme(const std::string& scheme) {
url::kDataScheme,
url::kFileScheme,
url::kFileSystemScheme,
#if !defined(DISABLE_FTP_SUPPORT)
#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
url::kFtpScheme,
#endif
};

2
libcef/common/request_impl.cc
View File

@ -786,7 +786,7 @@ void CefRequestImpl::Get(net::URLFetcher& fetcher,
}
if (!first_party_for_cookies_.is_empty())
fetcher.SetInitiatorURL(first_party_for_cookies_);
fetcher.SetInitiator(url::Origin(first_party_for_cookies_));
if (flags_ & UR_FLAG_NO_RETRY_ON_5XX)
fetcher.SetAutomaticallyRetryOn5xx(false);

18
libcef/common/task_runner_impl.cc
View File

@ -88,14 +88,8 @@ scoped_refptr<base::SequencedTaskRunner>
if (id >= 0 && CefContentClient::Get() &&
CefContentClient::Get()->browser() &&
BrowserThread::IsMessageLoopValid(static_cast<BrowserThread::ID>(id))) {
// Don't use BrowserThread::GetTaskRunnerForThread because it returns
// a new MessageLoopProxy object for each call and makes pointer equality
// testing impossible.
base::MessageLoop* message_loop =
BrowserThread::UnsafeGetMessageLoopForThread(
return BrowserThread::GetTaskRunnerForThread(
static_cast<BrowserThread::ID>(id));
if (message_loop)
return message_loop->task_runner();
}
return NULL;
@ -106,9 +100,19 @@ scoped_refptr<base::SequencedTaskRunner>
CefTaskRunnerImpl::GetCurrentTaskRunner() {
scoped_refptr<base::SequencedTaskRunner> task_runner;
// For named browser process threads return the same TaskRunner as
// GetTaskRunner(). Otherwise BelongsToThread() will return incorrect results.
BrowserThread::ID current_id;
if (BrowserThread::GetCurrentThreadIdentifier(&current_id) &&
BrowserThread::IsMessageLoopValid(current_id)) {
task_runner = BrowserThread::GetTaskRunnerForThread(current_id);
}
if (!task_runner.get()) {
// Check for a MessageLoopProxy. This covers all of the named browser and
// render process threads, plus a few extra.
task_runner = base::ThreadTaskRunnerHandle::Get();
}
if (!task_runner.get()) {
// Check for a WebWorker thread.

4
libcef/common/widevine_loader.cc
View File

@ -4,7 +4,7 @@
#include "libcef/common/widevine_loader.h"
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
#include "libcef/browser/context.h"
#include "libcef/browser/thread_util.h"
@ -403,4 +403,4 @@ CefWidevineLoader::CefWidevineLoader() {
CefWidevineLoader::~CefWidevineLoader() {
}
#endif // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#endif // defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)

4
libcef/common/widevine_loader.h
View File

@ -10,7 +10,7 @@
#include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
#include <vector>
@ -59,6 +59,6 @@ class CefWidevineLoader {
~CefWidevineLoader();
};
#endif // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
#endif // defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS)
#endif // CEF_LIBCEF_COMMON_WIDEVINE_LOADER_H_

64
libcef/renderer/browser_impl.cc
View File

@ -68,7 +68,7 @@ CefRefPtr<CefBrowserImpl> CefBrowserImpl::GetBrowserForMainFrame(
CefRefPtr<CefBrowserHost> CefBrowserImpl::GetHost() {
NOTREACHED() << "GetHost cannot be called from the render process";
return NULL;
return nullptr;
}
bool CefBrowserImpl::CanGoBack() {
@ -157,31 +157,31 @@ bool CefBrowserImpl::HasDocument() {
}
CefRefPtr<CefFrame> CefBrowserImpl::GetMainFrame() {
CEF_REQUIRE_RT_RETURN(NULL);
CEF_REQUIRE_RT_RETURN(nullptr);
if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame())
return GetWebFrameImpl(render_view()->GetWebView()->mainFrame()).get();
return NULL;
return nullptr;
}
CefRefPtr<CefFrame> CefBrowserImpl::GetFocusedFrame() {
CEF_REQUIRE_RT_RETURN(NULL);
CEF_REQUIRE_RT_RETURN(nullptr);
if (render_view()->GetWebView() &&
render_view()->GetWebView()->focusedFrame()) {
return GetWebFrameImpl(render_view()->GetWebView()->focusedFrame()).get();
}
return NULL;
return nullptr;
}
CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(int64 identifier) {
CEF_REQUIRE_RT_RETURN(NULL);
CEF_REQUIRE_RT_RETURN(nullptr);
return GetWebFrameImpl(identifier).get();
}
CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(const CefString& name) {
CEF_REQUIRE_RT_RETURN(NULL);
CEF_REQUIRE_RT_RETURN(nullptr);
blink::WebView* web_view = render_view()->GetWebView();
if (web_view) {
@ -198,7 +198,7 @@ CefRefPtr<CefFrame> CefBrowserImpl::GetFrame(const CefString& name) {
return GetWebFrameImpl(frame).get();
}
return NULL;
return nullptr;
}
size_t CefBrowserImpl::GetFrameCount() {
@ -207,13 +207,9 @@ size_t CefBrowserImpl::GetFrameCount() {
int count = 0;
if (render_view()->GetWebView()) {
WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
if (main_frame) {
WebFrame* cur = main_frame;
do {
for (WebFrame* frame = render_view()->GetWebView()->mainFrame(); frame;
frame = frame->traverseNext()) {
count++;
cur = cur->traverseNext(true);
} while (cur != main_frame);
}
}
@ -227,13 +223,9 @@ void CefBrowserImpl::GetFrameIdentifiers(std::vector<int64>& identifiers) {
identifiers.clear();
if (render_view()->GetWebView()) {
WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
if (main_frame) {
WebFrame* cur = main_frame;
do {
identifiers.push_back(webkit_glue::GetIdentifier(cur));
cur = cur->traverseNext(true);
} while (cur != main_frame);
for (WebFrame* frame = render_view()->GetWebView()->mainFrame(); frame;
frame = frame->traverseNext()) {
identifiers.push_back(webkit_glue::GetIdentifier(frame));
}
}
}
@ -245,13 +237,9 @@ void CefBrowserImpl::GetFrameNames(std::vector<CefString>& names) {
names.clear();
if (render_view()->GetWebView()) {
WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
if (main_frame) {
WebFrame* cur = main_frame;
do {
names.push_back(CefString(cur->uniqueName().utf8()));
cur = cur->traverseNext(true);
} while (cur != main_frame);
for (WebFrame* frame = render_view()->GetWebView()->mainFrame(); frame;
frame = frame->traverseNext()) {
names.push_back(CefString(frame->uniqueName().utf8()));
}
}
}
@ -347,7 +335,7 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64_t frame_id) {
if (frame_id == webkit_glue::kInvalidFrameId) {
if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame())
return GetWebFrameImpl(render_view()->GetWebView()->mainFrame());
return NULL;
return nullptr;
}
// Check if we already know about the frame.
@ -357,18 +345,14 @@ CefRefPtr<CefFrameImpl> CefBrowserImpl::GetWebFrameImpl(int64_t frame_id) {
if (render_view()->GetWebView()) {
// Check if the frame exists but we don't know about it yet.
WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
if (main_frame) {
WebFrame* cur = main_frame;
do {
if (webkit_glue::GetIdentifier(cur) == frame_id)
return GetWebFrameImpl(cur);
cur = cur->traverseNext(true);
} while (cur != main_frame);
for (WebFrame* frame = render_view()->GetWebView()->mainFrame(); frame;
frame = frame->traverseNext()) {
if (webkit_glue::GetIdentifier(frame) == frame_id)
return GetWebFrameImpl(frame);
}
}
return NULL;
return nullptr;
}
void CefBrowserImpl::AddFrameObject(int64_t frame_id,
@ -409,7 +393,7 @@ void CefBrowserImpl::OnDestruct() {
handler->OnBrowserDestroyed(this);
}
response_manager_.reset(NULL);
response_manager_.reset();
CefContentRendererClient::Get()->OnBrowserDestroyed(this);
}
@ -552,7 +536,7 @@ void CefBrowserImpl::OnRequest(const Cef_Request_Params& params) {
false, true));
success = handler->OnProcessMessageReceived(this, PID_BROWSER,
message.get());
message->Detach(NULL);
message->Detach(nullptr);
}
}
} else if (params.name == "execute-code") {

13
libcef/renderer/content_renderer_client.cc
View File

@ -106,6 +106,7 @@ class CefPrerenderingSupport : public blink::WebPrerenderingSupport {
void add(const blink::WebPrerender& prerender) override {}
void cancel(const blink::WebPrerender& prerender) override {}
void abandon(const blink::WebPrerender& prerender) override {}
void prefetchFinished() override {}
};
// Stub implementation of blink::WebPrerendererClient.
@ -186,9 +187,8 @@ CefContentRendererClient::CefContentRendererClient()
extensions::ExtensionsRendererClient::Set(
extensions_renderer_client_.get());
}
#if defined(ENABLE_PRINTING)
printing::SetAgent(CefContentClient::Get()->GetUserAgent());
#endif
}
CefContentRendererClient::~CefContentRendererClient() {
@ -467,6 +467,9 @@ void CefContentRendererClient::RenderFrameCreated(
content::RenderFrame* render_frame) {
new CefRenderFrameObserver(render_frame);
new CefPepperHelper(render_frame);
new printing::PrintWebViewHelper(
render_frame,
base::WrapUnique(new extensions::CefPrintWebViewHelperDelegate()));
if (extensions::ExtensionsEnabled())
extensions_renderer_client_->RenderFrameCreated(render_frame);
@ -477,9 +480,6 @@ void CefContentRendererClient::RenderFrameCreated(
void CefContentRendererClient::RenderViewCreated(
content::RenderView* render_view) {
new CefPrerendererClient(render_view);
new printing::PrintWebViewHelper(
render_view,
base::WrapUnique(new extensions::CefPrintWebViewHelperDelegate()));
if (extensions::ExtensionsEnabled())
extensions_renderer_client_->RenderViewCreated(render_view);
@ -598,8 +598,7 @@ bool CefContentRendererClient::ShouldFork(blink::WebLocalFrame* frame,
bool CefContentRendererClient::WillSendRequest(
blink::WebFrame* frame,
ui::PageTransition transition_type,
const GURL& url,
const GURL& first_party_for_cookies,
const blink::WebURL& url,
GURL* new_url) {
if (extensions::ExtensionsEnabled()) {
return extensions_renderer_client_->WillSendRequest(frame, transition_type,

5
libcef/renderer/content_renderer_client.h
View File

@ -113,8 +113,7 @@ class CefContentRendererClient : public content::ContentRendererClient,
bool* send_referrer) override;
bool WillSendRequest(blink::WebFrame* frame,
ui::PageTransition transition_type,
const GURL& url,
const GURL& first_party_for_cookies,
const blink::WebURL& url,
GURL* new_url) override;
unsigned long long VisitedLinkHash(const char* canonical_url,
size_t length) override;
@ -176,6 +175,8 @@ class CefContentRendererClient : public content::ContentRendererClient,
// Access must be protected by |single_process_cleanup_lock_|.
bool single_process_cleanup_complete_;
base::Lock single_process_cleanup_lock_;
DISALLOW_COPY_AND_ASSIGN(CefContentRendererClient);
};
#endif // CEF_LIBCEF_RENDERER_CONTENT_RENDERER_CLIENT_H_

2
libcef/renderer/dom_node_impl.cc
View File

@ -78,7 +78,7 @@ bool CefDOMNodeImpl::IsEditable() {
if (node_.isElementNode()) {
const WebElement& element = node_.toConst<WebElement>();
if (element.isTextFormControlElement())
if (webkit_glue::IsTextControlElement(element))
return true;
// Also return true if it has an ARIA role of 'textbox'.

10
libcef/renderer/extensions/extensions_renderer_client.cc
View File

@ -170,18 +170,18 @@ bool CefExtensionsRendererClient::OverrideCreatePlugin(
bool CefExtensionsRendererClient::WillSendRequest(
blink::WebFrame* frame,
ui::PageTransition transition_type,
const GURL& url,
const blink::WebURL& url,
GURL* new_url) {
// Check whether the request should be allowed. If not allowed, we reset the
// URL to something invalid to prevent the request and cause an error.
if (url.SchemeIs(extensions::kExtensionScheme) &&
!resource_request_policy_->CanRequestResource(url, frame,
if (url.protocolIs(extensions::kExtensionScheme) &&
!resource_request_policy_->CanRequestResource(GURL(url), frame,
transition_type)) {
*new_url = GURL(chrome::kExtensionInvalidRequestURL);
return true;
}
if (url.SchemeIs(extensions::kExtensionResourceScheme) &&
if (url.protocolIs(extensions::kExtensionResourceScheme) &&
!resource_request_policy_->CanRequestExtensionResourceScheme(url,
frame)) {
*new_url = GURL(chrome::kExtensionResourceInvalidRequestURL);
@ -239,7 +239,7 @@ bool CefExtensionsRendererClient::ShouldFork(blink::WebLocalFrame* frame,
// for subframes, so this check only makes sense for top-level frames.
// TODO(alexmos,nasko): Figure out how this check should work when reloading
// subframes in --site-per-process mode.
if (!frame->parent() && frame->document().url() == url) {
if (!frame->parent() && GURL(frame->document().url()) == url) {
if (is_extension_url != IsStandaloneExtensionProcess())
return true;
}

3
libcef/renderer/extensions/extensions_renderer_client.h
View File

@ -18,6 +18,7 @@ namespace blink {
class WebFrame;
class WebLocalFrame;
struct WebPluginParams;
class WebURL;
}
namespace content {
@ -50,7 +51,7 @@ class CefExtensionsRendererClient : public ExtensionsRendererClient {
const blink::WebPluginParams& params);
bool WillSendRequest(blink::WebFrame* frame,
ui::PageTransition transition_type,
const GURL& url,
const blink::WebURL& url,
GURL* new_url);
void RunScriptsAtDocumentStart(content::RenderFrame* render_frame);
void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame);

2
libcef/renderer/extensions/print_web_view_helper_delegate.cc
View File

@ -22,7 +22,7 @@ CefPrintWebViewHelperDelegate::~CefPrintWebViewHelperDelegate(){
}
bool CefPrintWebViewHelperDelegate::CancelPrerender(
content::RenderView* render_view, int routing_id) {
content::RenderFrame* render_frame) {
return false;
}

3
libcef/renderer/extensions/print_web_view_helper_delegate.h
View File

@ -14,8 +14,7 @@ class CefPrintWebViewHelperDelegate
public:
~CefPrintWebViewHelperDelegate() override;
bool CancelPrerender(content::RenderView* render_view,
int routing_id) override;
bool CancelPrerender(content::RenderFrame* render_frame) override;
blink::WebElement GetPdfElement(blink::WebLocalFrame* frame) override;
bool IsPrintPreviewEnabled() override;
bool OverridePrint(blink::WebLocalFrame* frame) override;

9
libcef/renderer/media/cef_key_systems.cc
View File

@ -16,6 +16,7 @@
#include "libcef/common/cef_messages.h"
#include "media/base/eme_constants.h"
#include "media/base/key_system_properties.h"
#include "ppapi/features/features.h"
#include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
@ -31,7 +32,7 @@ using media::SupportedCodecs;
namespace {
#if defined(ENABLE_PEPPER_CDMS)
#if BUILDFLAG(ENABLE_PEPPER_CDMS)
bool IsPepperCdmAvailable(
const std::string& pepper_type,
std::vector<base::string16>* additional_param_names,
@ -135,15 +136,15 @@ void AddPepperBasedWidevine(
media::EmeFeatureSupport::NOT_SUPPORTED)); // Distinctive identifier.
}
#endif // defined(WIDEVINE_CDM_AVAILABLE)
#endif // defined(ENABLE_PEPPER_CDMS)
#endif // BUILDFLAG(ENABLE_PEPPER_CDMS)
} // namespace
void AddCefKeySystems(
std::vector<std::unique_ptr<KeySystemProperties>>* key_systems_properties) {
#if defined(ENABLE_PEPPER_CDMS)
#if BUILDFLAG(ENABLE_PEPPER_CDMS)
#if defined(WIDEVINE_CDM_AVAILABLE)
AddPepperBasedWidevine(key_systems_properties);
#endif // defined(WIDEVINE_CDM_AVAILABLE)
#endif // defined(ENABLE_PEPPER_CDMS)
#endif // BUILDFLAG(ENABLE_PEPPER_CDMS)
}

2
libcef/renderer/plugins/cef_plugin_placeholder.cc
View File

@ -24,8 +24,8 @@
#include "content/public/renderer/render_thread.h"
#include "gin/object_template_builder.h"
#include "third_party/WebKit/public/platform/URLConversion.h"
#include "third_party/WebKit/public/platform/WebInputEvent.h"
#include "third_party/WebKit/public/web/WebDocument.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
#include "third_party/WebKit/public/web/WebScriptSource.h"
#include "third_party/WebKit/public/web/WebView.h"

2
libcef/renderer/render_thread_observer.cc
View File

@ -11,7 +11,7 @@
#include "components/visitedlink/renderer/visitedlink_slave.h"
#include "content/public/renderer/render_thread.h"
#include "net/base/net_module.h"
#include "services/shell/public/cpp/interface_registry.h"
#include "services/service_manager/public/cpp/interface_registry.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/platform/WebURL.h"
#include "third_party/WebKit/public/web/WebSecurityPolicy.h"

5
libcef/renderer/webkit_glue.cc
View File

@ -186,6 +186,11 @@ v8::MaybeLocal<v8::Value> CallV8Function(v8::Local<v8::Context> context,
return func_rv;
}
bool IsTextControlElement(const blink::WebElement& element) {
const blink::Element* web_element = element.constUnwrap<blink::Element>();
return web_element->isTextControl();
}
v8::MaybeLocal<v8::Value> ExecuteV8ScriptAndReturnValue(
const blink::WebString& source,
const blink::WebString& source_url,

3
libcef/renderer/webkit_glue.h
View File

@ -15,6 +15,7 @@
#include "v8/include/v8.h"
namespace blink {
class WebElement;
class WebFrame;
class WebNode;
class WebString;
@ -46,6 +47,8 @@ int64_t GetIdentifier(blink::WebFrame* frame);
blink::WebFrame* FindFrameByUniqueName(const blink::WebString& unique_name,
blink::WebFrame* relative_to_frame);
bool IsTextControlElement(const blink::WebElement& element);
v8::MaybeLocal<v8::Value> CallV8Function(v8::Local<v8::Context> context,
v8::Local<v8::Function> function,
v8::Local<v8::Object> receiver,

3
libcef/resources/cef_resources.grd
View File

@ -15,6 +15,9 @@
<!-- Extension features supported by CEF. -->
<include name="IDR_CEF_EXTENSION_API_FEATURES" file="..\common\extensions\api\_api_features.json" type="BINDATA" />
<include name="IDR_CEF_BROWSER_MANIFEST_OVERLAY" file="..\common\extensions\api\browser_manifest_overlay.json" type="BINDATA" />
<include name="IDR_CEF_RENDERER_MANIFEST_OVERLAY" file="..\common\extensions\api\renderer_manifest_overlay.json" type="BINDATA" />
<include name="IDR_CEF_UTILITY_MANIFEST_OVERLAY" file="..\common\extensions\api\utility_manifest_overlay.json" type="BINDATA" />
</includes>
</release>
</grit>

8
libcef/utility/content_utility_client.cc
View File

@ -12,10 +12,10 @@
#include "chrome/utility/utility_message_handler.h"
#include "mojo/public/cpp/bindings/strong_binding.h"
#include "net/proxy/mojo_proxy_resolver_factory_impl.h"
#include "services/shell/public/cpp/interface_registry.h"
#include "services/service_manager/public/cpp/interface_registry.h"
#if defined(OS_WIN)
#include "libcef/utility/printing_handler.h"
#include "chrome/utility/printing_handler.h"
#endif
namespace {
@ -30,7 +30,7 @@ void CreateProxyResolverFactory(
CefContentUtilityClient::CefContentUtilityClient() {
#if defined(OS_WIN)
handlers_.push_back(new PrintingHandler());
handlers_.push_back(new printing::PrintingHandler());
#endif
}
@ -50,7 +50,7 @@ bool CefContentUtilityClient::OnMessageReceived(
}
void CefContentUtilityClient::ExposeInterfacesToBrowser(
shell::InterfaceRegistry* registry) {
service_manager::InterfaceRegistry* registry) {
registry->AddInterface<net::interfaces::ProxyResolverFactory>(
base::Bind(CreateProxyResolverFactory));
}

3
libcef/utility/content_utility_client.h
View File

@ -17,7 +17,8 @@ class CefContentUtilityClient : public content::ContentUtilityClient {
~CefContentUtilityClient() override;
bool OnMessageReceived(const IPC::Message& message) override;
void ExposeInterfacesToBrowser(shell::InterfaceRegistry* registry) override;
void ExposeInterfacesToBrowser(
service_manager::InterfaceRegistry* registry) override;
private:
typedef ScopedVector<UtilityMessageHandler> Handlers;

163
libcef/utility/printing_handler.cc
View File

@ -1,163 +0,0 @@
// Copyright 2014 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 "libcef/utility/printing_handler.h"
#include <stdint.h>
#include <utility>
#include "base/files/file_util.h"
#include "base/lazy_instance.h"
#include "base/path_service.h"
#include "base/scoped_native_library.h"
#include "build/build_config.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_utility_printing_messages.h"
#include "content/public/utility/utility_thread.h"
#include "printing/page_range.h"
#include "printing/pdf_render_settings.h"
#if defined(OS_WIN)
#include "base/win/iat_patch_function.h"
#include "printing/emf_win.h"
#include "ui/gfx/gdi_util.h"
#endif
namespace {
bool Send(IPC::Message* message) {
return content::UtilityThread::Get()->Send(message);
}
void ReleaseProcessIfNeeded() {
content::UtilityThread::Get()->ReleaseProcessIfNeeded();
}
#if defined(OS_WIN)
void PreCacheFontCharacters(const LOGFONT* logfont,
const wchar_t* text,
size_t text_length) {
Send(new ChromeUtilityHostMsg_PreCacheFontCharacters(
*logfont, base::string16(text, text_length)));
}
#endif
} // namespace
PrintingHandler::PrintingHandler() {
#if defined(OS_WIN)
chrome_pdf::SetPDFEnsureTypefaceCharactersAccessible(PreCacheFontCharacters);
#endif
}
PrintingHandler::~PrintingHandler() {}
bool PrintingHandler::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(PrintingHandler, message)
#if defined(OS_WIN)
IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafiles,
OnRenderPDFPagesToMetafile)
IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafiles_GetPage,
OnRenderPDFPagesToMetafileGetPage)
IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafiles_Stop,
OnRenderPDFPagesToMetafileStop)
#endif // OS_WIN
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
#if defined(OS_WIN)
void PrintingHandler::OnRenderPDFPagesToMetafile(
IPC::PlatformFileForTransit pdf_transit,
const printing::PdfRenderSettings& settings,
bool print_text_with_gdi) {
pdf_rendering_settings_ = settings;
chrome_pdf::SetPDFUseGDIPrinting(print_text_with_gdi);
base::File pdf_file = IPC::PlatformFileForTransitToFile(pdf_transit);
int page_count = LoadPDF(std::move(pdf_file));
Send(
new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount(page_count));
}
void PrintingHandler::OnRenderPDFPagesToMetafileGetPage(
int page_number,
IPC::PlatformFileForTransit output_file) {
base::File emf_file = IPC::PlatformFileForTransitToFile(output_file);
double scale_factor = 1.0;
bool success =
RenderPdfPageToMetafile(page_number, std::move(emf_file), &scale_factor);
Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageDone(
success, scale_factor));
}
void PrintingHandler::OnRenderPDFPagesToMetafileStop() {
ReleaseProcessIfNeeded();
}
int PrintingHandler::LoadPDF(base::File pdf_file) {
int64_t length = pdf_file.GetLength();
if (length < 0)
return 0;
pdf_data_.resize(length);
if (length != pdf_file.Read(0, pdf_data_.data(), pdf_data_.size()))
return 0;
int total_page_count = 0;
if (!chrome_pdf::GetPDFDocInfo(
&pdf_data_.front(), pdf_data_.size(), &total_page_count, NULL)) {
return 0;
}
return total_page_count;
}
bool PrintingHandler::RenderPdfPageToMetafile(int page_number,
base::File output_file,
double* scale_factor) {
printing::Emf metafile;
metafile.Init();
// We need to scale down DC to fit an entire page into DC available area.
// Current metafile is based on screen DC and have current screen size.
// Writing outside of those boundaries will result in the cut-off output.
// On metafiles (this is the case here), scaling down will still record
// original coordinates and we'll be able to print in full resolution.
// Before playback we'll need to counter the scaling up that will happen
// in the service (print_system_win.cc).
*scale_factor =
gfx::CalculatePageScale(metafile.context(),
pdf_rendering_settings_.area().right(),
pdf_rendering_settings_.area().bottom());
gfx::ScaleDC(metafile.context(), *scale_factor);
// The underlying metafile is of type Emf and ignores the arguments passed
// to StartPage.
metafile.StartPage(gfx::Size(), gfx::Rect(), 1);
if (!chrome_pdf::RenderPDFPageToDC(
&pdf_data_.front(),
pdf_data_.size(),
page_number,
metafile.context(),
pdf_rendering_settings_.dpi(),
pdf_rendering_settings_.area().x(),
pdf_rendering_settings_.area().y(),
pdf_rendering_settings_.area().width(),
pdf_rendering_settings_.area().height(),
true,
false,
true,
true,
pdf_rendering_settings_.autorotate())) {
return false;
}
metafile.FinishPage();
metafile.FinishDocument();
return metafile.SaveTo(&output_file);
}
#endif // OS_WIN

57
libcef/utility/printing_handler.h
View File

@ -1,57 +0,0 @@
// Copyright 2014 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.
#ifndef LIBCEF_UTILITY_PRINTING_HANDLER_H_
#define LIBCEF_UTILITY_PRINTING_HANDLER_H_
#include "base/compiler_specific.h"
#include "base/macros.h"
#include "chrome/utility/utility_message_handler.h"
#include "ipc/ipc_platform_file.h"
#include "pdf/pdf.h"
#include "printing/pdf_render_settings.h"
#if !defined(OS_WIN)
#error "Must be building on Windows."
#endif
namespace printing {
class PdfRenderSettings;
struct PwgRasterSettings;
struct PageRange;
}
// Dispatches IPCs for printing.
class PrintingHandler : public UtilityMessageHandler {
public:
PrintingHandler();
~PrintingHandler() override;
// IPC::Listener:
bool OnMessageReceived(const IPC::Message& message) override;
private:
// IPC message handlers.
#if defined(OS_WIN)
void OnRenderPDFPagesToMetafile(IPC::PlatformFileForTransit pdf_transit,
const printing::PdfRenderSettings& settings,
bool print_text_with_gdi);
void OnRenderPDFPagesToMetafileGetPage(
int page_number,
IPC::PlatformFileForTransit output_file);
void OnRenderPDFPagesToMetafileStop();
int LoadPDF(base::File pdf_file);
bool RenderPdfPageToMetafile(int page_number,
base::File output_file,
double* scale_factor);
std::vector<char> pdf_data_;
printing::PdfRenderSettings pdf_rendering_settings_;
#endif // defined(OS_WIN)
DISALLOW_COPY_AND_ASSIGN(PrintingHandler);
};
#endif // LIBCEF_UTILITY_PRINTING_HANDLER_H_

8
patch/patch.cfg
View File

@ -209,7 +209,7 @@ patches = [
# Enable support for filtering resource responses.
# https://bitbucket.org/chromiumembedded/cef/issues/515
'name': 'net_filter_515',
'path': '../net/',
'path': '../',
},
{
# Modify views::View to extend SupportsUserData.
@ -288,4 +288,10 @@ patches = [
'name': 'net_security_expiration_1994',
'path': '../',
},
{
# Remove DCHECK hit during latency reporting when using OSR.
# https://bitbucket.org/chromiumembedded/cef/issues/2060
'name': 'render_widget_latency_2060',
'path': '../',
},
]

10
patch/patches/browser_compositor_mac.patch
View File

@ -1,8 +1,8 @@
diff --git content/browser/renderer_host/browser_compositor_view_mac.h content/browser/renderer_host/browser_compositor_view_mac.h
index 4b8d5bc..6a1b374 100644
index 865b29f..ef44e27 100644
--- content/browser/renderer_host/browser_compositor_view_mac.h
+++ content/browser/renderer_host/browser_compositor_view_mac.h
@@ -56,9 +56,11 @@ class BrowserCompositorMac : public cc::BeginFrameObserver,
@@ -55,9 +55,11 @@ class BrowserCompositorMac : public cc::BeginFrameObserver,
// These will not return nullptr until Destroy is called.
DelegatedFrameHost* GetDelegatedFrameHost();
@ -15,10 +15,10 @@ index 4b8d5bc..6a1b374 100644
void SwapCompositorFrame(uint32_t compositor_frame_sink_id,
diff --git content/browser/renderer_host/browser_compositor_view_mac.mm content/browser/renderer_host/browser_compositor_view_mac.mm
index 3ec7423..14d5add 100644
index 4ff716d..aaf17b2 100644
--- content/browser/renderer_host/browser_compositor_view_mac.mm
+++ content/browser/renderer_host/browser_compositor_view_mac.mm
@@ -200,6 +200,12 @@ BrowserCompositorMac::~BrowserCompositorMac() {
@@ -199,6 +199,12 @@ BrowserCompositorMac::~BrowserCompositorMac() {
g_spare_recyclable_compositors.Get().clear();
}
@ -31,7 +31,7 @@ index 3ec7423..14d5add 100644
ui::AcceleratedWidgetMac* BrowserCompositorMac::GetAcceleratedWidgetMac() {
if (recyclable_compositor_)
return recyclable_compositor_->accelerated_widget_mac();
@@ -417,8 +423,13 @@ SkColor BrowserCompositorMac::DelegatedFrameHostGetGutterColor(
@@ -416,8 +422,13 @@ SkColor BrowserCompositorMac::DelegatedFrameHostGetGutterColor(
}
gfx::Size BrowserCompositorMac::DelegatedFrameHostDesiredSizeInDIP() const {

14
patch/patches/browser_frame_host_guest_1687.patch
View File

@ -1,14 +1,22 @@
diff --git render_widget_host_view_guest.cc render_widget_host_view_guest.cc
index 7122187..19dec1a 100644
index c628e20..3c4e008d 100644
--- render_widget_host_view_guest.cc
+++ render_widget_host_view_guest.cc
@@ -253,6 +253,9 @@ void RenderWidgetHostViewGuest::Destroy() {
@@ -253,13 +253,14 @@ void RenderWidgetHostViewGuest::Destroy() {
}
gfx::Size RenderWidgetHostViewGuest::GetPhysicalBackingSize() const {
+ RenderWidgetHostViewBase* rwhv = GetOwnerRenderWidgetHostView();
+ if (rwhv)
+ return rwhv->GetPhysicalBackingSize();
return RenderWidgetHostViewBase::GetPhysicalBackingSize();
// We obtain the reference to native view from the owner RenderWidgetHostView.
// If the guest is embedded inside a cross-process frame, it is possible to
// reach here after the frame is detached in which case there will be no owner
// view.
- if (!GetOwnerRenderWidgetHostView())
- return gfx::Size();
- return RenderWidgetHostViewBase::GetPhysicalBackingSize();
+ return gfx::Size();
}
base::string16 RenderWidgetHostViewGuest::GetSelectedText() {

27
patch/patches/browser_plugin_guest_1565.patch
View File

@ -1,8 +1,8 @@
diff --git browser/browser_plugin/browser_plugin_guest.cc browser/browser_plugin/browser_plugin_guest.cc
index 2dc039f..66e45e2 100644
index d4d4f14..977e24e 100644
--- browser/browser_plugin/browser_plugin_guest.cc
+++ browser/browser_plugin/browser_plugin_guest.cc
@@ -28,7 +28,7 @@
@@ -29,7 +29,7 @@
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/browser/renderer_host/render_widget_host_view_base.h"
#include "content/browser/web_contents/web_contents_impl.h"
@ -11,7 +11,7 @@ index 2dc039f..66e45e2 100644
#include "content/common/browser_plugin/browser_plugin_constants.h"
#include "content/common/browser_plugin/browser_plugin_messages.h"
#include "content/common/content_constants_internal.h"
@@ -293,20 +293,19 @@ void BrowserPluginGuest::InitInternal(
@@ -310,20 +310,19 @@ void BrowserPluginGuest::InitInternal(
guest_window_rect_ = params.view_rect;
if (owner_web_contents_ != owner_web_contents) {
@ -36,7 +36,7 @@ index 2dc039f..66e45e2 100644
}
RendererPreferences* renderer_prefs =
@@ -758,11 +757,10 @@ void BrowserPluginGuest::OnWillAttachComplete(
@@ -796,11 +795,10 @@ void BrowserPluginGuest::OnWillAttachComplete(
->GetWidget()
->Init();
GetWebContents()->GetMainFrame()->Init();
@ -52,7 +52,7 @@ index 2dc039f..66e45e2 100644
}
diff --git public/browser/browser_plugin_guest_delegate.cc public/browser/browser_plugin_guest_delegate.cc
index 732df23..25dbc62 100644
index 8d691ef..eb13b5d 100644
--- public/browser/browser_plugin_guest_delegate.cc
+++ public/browser/browser_plugin_guest_delegate.cc
@@ -4,6 +4,8 @@
@ -64,8 +64,8 @@ index 732df23..25dbc62 100644
namespace content {
bool BrowserPluginGuestDelegate::CanRunInDetachedState() const {
@@ -36,4 +38,23 @@ bool BrowserPluginGuestDelegate::CanUseCrossProcessFrames() {
return true;
@@ -48,4 +50,23 @@ SiteInstance* BrowserPluginGuestDelegate::GetOwnerSiteInstance() {
return nullptr;
}
+void BrowserPluginGuestDelegate::OnGuestAttached(
@ -89,19 +89,18 @@ index 732df23..25dbc62 100644
+
} // namespace content
diff --git public/browser/browser_plugin_guest_delegate.h public/browser/browser_plugin_guest_delegate.h
index 0f805651..fe0385d 100644
index a32205c..1d93d7b 100644
--- public/browser/browser_plugin_guest_delegate.h
+++ public/browser/browser_plugin_guest_delegate.h
@@ -21,6 +21,8 @@ class Size;
namespace content {
@@ -19,6 +19,7 @@ namespace content {
class GuestHost;
+class RenderWidgetHost;
class RenderWidgetHost;
class SiteInstance;
+class WebContentsView;
// Objects implement this interface to get notified about changes in the guest
// WebContents and to provide necessary functionality.
@@ -87,6 +89,17 @@ class CONTENT_EXPORT BrowserPluginGuestDelegate {
@@ -85,6 +86,17 @@ class CONTENT_EXPORT BrowserPluginGuestDelegate {
// content module.
virtual void SetGuestHost(GuestHost* guest_host) {}
@ -118,4 +117,4 @@ index 0f805651..fe0385d 100644
+
// Sets the position of the context menu for the guest contents. The value
// reported from the guest renderer should be ignored. The reported value
// fromt he guest renderer is incorrect in situations where BrowserPlugin is
// from the guest renderer is incorrect in situations where BrowserPlugin is

8
patch/patches/chrome_profile.patch
View File

@ -63,10 +63,10 @@ index 4b43013..169ca47 100644
content::BrowserContext* GetBrowserContextRedirectedInIncognito(
content::BrowserContext* context);
diff --git chrome/browser/profiles/profile_manager.h chrome/browser/profiles/profile_manager.h
index ba156c5..0ed578b 100644
index f715370..fb38098 100644
--- chrome/browser/profiles/profile_manager.h
+++ chrome/browser/profiles/profile_manager.h
@@ -89,7 +89,7 @@ class ProfileManager : public base::NonThreadSafe,
@@ -90,7 +90,7 @@ class ProfileManager : public base::NonThreadSafe,
// acceptable. Returns null if creation of the new profile fails.
// TODO(bauerb): Migrate calls from other code to GetProfileByPath(), then
// make this method private.
@ -75,7 +75,7 @@ index ba156c5..0ed578b 100644
// Returns total number of profiles available on this machine.
size_t GetNumberOfProfiles();
@@ -117,7 +117,7 @@ class ProfileManager : public base::NonThreadSafe,
@@ -118,7 +118,7 @@ class ProfileManager : public base::NonThreadSafe,
// Returns true if the profile pointer is known to point to an existing
// profile.
@ -84,7 +84,7 @@ index ba156c5..0ed578b 100644
// Returns the directory where the first created profile is stored,
// relative to the user data directory currently in use.
@@ -126,7 +126,7 @@ class ProfileManager : public base::NonThreadSafe,
@@ -127,7 +127,7 @@ class ProfileManager : public base::NonThreadSafe,
// Get the Profile last used (the Profile to which owns the most recently
// focused window) with this Chrome build. If no signed profile has been
// stored in Local State, hand back the Default profile.

6
patch/patches/chrome_widevine.patch
View File

@ -1,11 +1,11 @@
diff --git chrome/common/chrome_content_client.cc chrome/common/chrome_content_client.cc
index 616c9b1..cf1c881 100644
index bb7757b..532f036 100644
--- chrome/common/chrome_content_client.cc
+++ chrome/common/chrome_content_client.cc
@@ -77,7 +77,7 @@
@@ -78,7 +78,7 @@
#endif
#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
#if defined(WIDEVINE_CDM_AVAILABLE) && BUILDFLAG(ENABLE_PEPPER_CDMS) && \
- !defined(WIDEVINE_CDM_IS_COMPONENT)
+ !defined(WIDEVINE_CDM_IS_COMPONENT) && defined(WIDEVINE_CDM_VERSION_STRING)
#define WIDEVINE_CDM_AVAILABLE_NOT_COMPONENT

12
patch/patches/compositor_1368.patch
View File

@ -1,5 +1,5 @@
diff --git content/browser/compositor/gpu_process_transport_factory.cc content/browser/compositor/gpu_process_transport_factory.cc
index 73ee42f..b30dc83 100644
index 7d1cf0c..a806826 100644
--- content/browser/compositor/gpu_process_transport_factory.cc
+++ content/browser/compositor/gpu_process_transport_factory.cc
@@ -196,6 +196,13 @@ GpuProcessTransportFactory::~GpuProcessTransportFactory() {
@ -14,10 +14,10 @@ index 73ee42f..b30dc83 100644
+ }
+
#if defined(USE_AURA)
if (shell::ShellIsRemote()) {
if (service_manager::ServiceManagerIsRemote()) {
NOTREACHED();
diff --git ui/compositor/compositor.h ui/compositor/compositor.h
index 6a6b423..4a0d9e4 100644
index 76f8f38..0fdc07b 100644
--- ui/compositor/compositor.h
+++ ui/compositor/compositor.h
@@ -18,6 +18,7 @@
@ -28,7 +28,7 @@ index 6a6b423..4a0d9e4 100644
#include "cc/surfaces/surface_sequence.h"
#include "cc/trees/layer_tree_host_client.h"
#include "cc/trees/layer_tree_host_single_thread_client.h"
@@ -195,6 +196,17 @@ class COMPOSITOR_EXPORT CompositorLock
@@ -188,6 +189,17 @@ class COMPOSITOR_EXPORT CompositorLock
DISALLOW_COPY_AND_ASSIGN(CompositorLock);
};
@ -46,7 +46,7 @@ index 6a6b423..4a0d9e4 100644
// Compositor object to take care of GPU painting.
// A Browser compositor object is responsible for generating the final
// displayable form of pixels comprising a single widget's contents. It draws an
@@ -218,6 +230,9 @@ class COMPOSITOR_EXPORT Compositor
@@ -211,6 +223,9 @@ class COMPOSITOR_EXPORT Compositor
// Schedules a redraw of the layer tree associated with this compositor.
void ScheduleDraw();
@ -56,7 +56,7 @@ index 6a6b423..4a0d9e4 100644
// Sets the root of the layer tree drawn by this Compositor. The root layer
// must have no parent. The compositor's root layer is reset if the root layer
// is destroyed. NULL can be passed to reset the root layer, in which case the
@@ -400,6 +415,8 @@ class COMPOSITOR_EXPORT Compositor
@@ -393,6 +408,8 @@ class COMPOSITOR_EXPORT Compositor
ui::ContextFactory* context_factory_;

14
patch/patches/content_nav_1129.patch
View File

@ -1,5 +1,5 @@
diff --git public/renderer/content_renderer_client.cc public/renderer/content_renderer_client.cc
index bb040a6..c801841 100644
index 642521f..8fb647f 100644
--- public/renderer/content_renderer_client.cc
+++ public/renderer/content_renderer_client.cc
@@ -100,7 +100,6 @@ bool ContentRendererClient::AllowPopup() {
@ -19,10 +19,10 @@ index bb040a6..c801841 100644
return false;
}
diff --git public/renderer/content_renderer_client.h public/renderer/content_renderer_client.h
index 14d8550..92e5b21 100644
index f2a854f..913e30c 100644
--- public/renderer/content_renderer_client.h
+++ public/renderer/content_renderer_client.h
@@ -208,7 +208,6 @@ class CONTENT_EXPORT ContentRendererClient {
@@ -204,7 +204,6 @@ class CONTENT_EXPORT ContentRendererClient {
// Returns true if a popup window should be allowed.
virtual bool AllowPopup();
@ -30,7 +30,7 @@ index 14d8550..92e5b21 100644
// TODO(sgurun) This callback is deprecated and will be removed as soon
// as android webview completes implementation of a resource throttle based
// shouldoverrideurl implementation. See crbug.com/325351
@@ -224,6 +223,7 @@ class CONTENT_EXPORT ContentRendererClient {
@@ -220,6 +219,7 @@ class CONTENT_EXPORT ContentRendererClient {
blink::WebNavigationPolicy default_policy,
bool is_redirect);
@ -39,10 +39,10 @@ index 14d8550..92e5b21 100644
// built in media player for the given |url|. Defaults to false.
virtual bool ShouldUseMediaPlayerForURL(const GURL& url);
diff --git renderer/render_frame_impl.cc renderer/render_frame_impl.cc
index 8880b8d..cab954b 100644
index 2f79ac0..7e0c73b 100644
--- renderer/render_frame_impl.cc
+++ renderer/render_frame_impl.cc
@@ -5008,7 +5008,6 @@ WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
@@ -5112,7 +5112,6 @@ WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
(pending_navigation_params_ &&
!pending_navigation_params_->request_params.redirects.empty());
@ -50,7 +50,7 @@ index 8880b8d..cab954b 100644
// The handlenavigation API is deprecated and will be removed once
// crbug.com/325351 is resolved.
if (GetContentClient()->renderer()->HandleNavigation(
@@ -5017,7 +5016,6 @@ WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
@@ -5121,7 +5120,6 @@ WebNavigationPolicy RenderFrameImpl::decidePolicyForNavigation(
is_redirect)) {
return blink::WebNavigationPolicyIgnore;
}

22
patch/patches/gn_config.patch
View File

@ -1,8 +1,8 @@
diff --git .gn .gn
index 585f0d8..9f60467 100644
index e4b474a..38a41be 100644
--- .gn
+++ .gn
@@ -237,6 +237,7 @@ exec_script_whitelist = [
@@ -241,6 +241,7 @@ exec_script_whitelist = [
"//build/toolchain/win/BUILD.gn",
"//build/util/branding.gni",
"//build/util/version.gni",
@ -11,10 +11,10 @@ index 585f0d8..9f60467 100644
# TODO(dgn): Layer violation but breaks the build otherwise, see
diff --git BUILD.gn BUILD.gn
index 93699f0..3346d3e 100644
index 43c7b3d..df225a1 100644
--- BUILD.gn
+++ BUILD.gn
@@ -280,6 +280,7 @@ group("both_gn_and_gyp") {
@@ -282,6 +282,7 @@ group("both_gn_and_gyp") {
# and whether there should be other targets that are iOS-only and missing.
deps += [
"//cc:cc_unittests",
@ -23,11 +23,11 @@ index 93699f0..3346d3e 100644
"//chrome/test:unit_tests",
"//components:components_browsertests",
diff --git build/config/win/visual_studio_version.gni build/config/win/visual_studio_version.gni
index 5bfa9a7..5e6e05d 100644
index 982fbe8..e757be46 100644
--- build/config/win/visual_studio_version.gni
+++ build/config/win/visual_studio_version.gni
@@ -12,9 +12,8 @@ declare_args() {
# Use "2013" for Visual Studio 2013, or "2013e" for the Express version.
# Currently always "2015".
visual_studio_version = ""
- # Directory of the Windows driver kit. If visual_studio_path is empty, this
@ -80,7 +80,7 @@ index fbc201e..299156d 100644
diff --git build/vs_toolchain.py build/vs_toolchain.py
index 9c55984..d44d116 100755
index c768a8a..bb91777 100755
--- build/vs_toolchain.py
+++ build/vs_toolchain.py
@@ -74,11 +74,18 @@ def SetEnvironmentAndGetRuntimeDllDirs():
@ -103,10 +103,10 @@ index 9c55984..d44d116 100755
# directory in order to run binaries locally, but they are needed in order
# to create isolates or the mini_installer. Copying them to the output
diff --git chrome/chrome_paks.gni chrome/chrome_paks.gni
index 3e93269..9821a4b 100644
index c3ac484..13ae760 100644
--- chrome/chrome_paks.gni
+++ chrome/chrome_paks.gni
@@ -233,7 +233,7 @@ template("chrome_paks") {
@@ -235,7 +235,7 @@ template("chrome_paks") {
additional_source_patterns = invoker.additional_locale_source_patterns
}
input_locales = locales
@ -116,10 +116,10 @@ index 3e93269..9821a4b 100644
if (is_mac) {
output_locales = locales_as_mac_outputs
diff --git chrome/installer/mini_installer/BUILD.gn chrome/installer/mini_installer/BUILD.gn
index 6994618..4ed3f85 100644
index 0f37e54..7b81cde 100644
--- chrome/installer/mini_installer/BUILD.gn
+++ chrome/installer/mini_installer/BUILD.gn
@@ -125,7 +125,7 @@ template("generate_mini_installer") {
@@ -124,7 +124,7 @@ template("generate_mini_installer") {
inputs = [
"$chrome_dll_file",
"$root_out_dir/chrome.exe",

14
patch/patches/gritsettings.patch
View File

@ -1,10 +1,10 @@
diff --git resource_ids resource_ids
index 82347ce..8e09968 100644
index c500512..0ac0e98 100644
--- resource_ids
+++ resource_ids
@@ -14,6 +14,12 @@
{
"SRCDIR": "../..",
@@ -358,5 +358,12 @@
# Thinking about appending to the end?
# Please read the header and find the right section above instead.
+ "cef/libcef/resources/cef_resources.grd": {
+ "includes": [31500],
@ -12,6 +12,6 @@ index 82347ce..8e09968 100644
+ "cef/libcef/resources/cef_strings.grd": {
+ "messages": [32000],
+ },
"chrome/browser/browser_resources.grd": {
"includes": [400],
"structures": [850],
+
# Resource ids starting at 31000 are reserved for projects built on Chromium.
}

4
patch/patches/ime_1610.patch
View File

@ -1,8 +1,8 @@
diff --git input_method_win.cc input_method_win.cc
index 8975069..858bc9b 100644
index 49efa46..c9eb806 100644
--- input_method_win.cc
+++ input_method_win.cc
@@ -642,8 +642,9 @@ bool InputMethodWin::IsWindowFocused(const TextInputClient* client) const {
@@ -664,8 +664,9 @@ bool InputMethodWin::IsWindowFocused(const TextInputClient* client) const {
// receiving keyboard input as long as it is an active window. This works well
// even when the |attached_window_handle| becomes active but has not received
// WM_FOCUS yet.

16
patch/patches/message_loop_443_1992243003.patch
View File

@ -1,5 +1,5 @@
diff --git message_loop.cc message_loop.cc
index 74287b1..7309e88 100644
index 1581f6c..ecb3149 100644
--- message_loop.cc
+++ message_loop.cc
@@ -96,12 +96,6 @@ MessageLoop::~MessageLoop() {
@ -15,7 +15,7 @@ index 74287b1..7309e88 100644
#if defined(OS_WIN)
if (in_high_res_mode_)
Time::ActivateHighResolutionTimer(false);
@@ -313,6 +307,9 @@ MessageLoop::MessageLoop(Type type, MessagePumpFactoryCallback pump_factory)
@@ -319,6 +313,9 @@ MessageLoop::MessageLoop(Type type, MessagePumpFactoryCallback pump_factory)
in_high_res_mode_(false),
#endif
nestable_tasks_allowed_(true),
@ -26,7 +26,7 @@ index 74287b1..7309e88 100644
run_loop_(NULL),
incoming_task_queue_(new internal::IncomingTaskQueue(this)),
diff --git message_loop.h message_loop.h
index 5b1728e..79c4c58 100644
index ac7a303..b39018b 100644
--- message_loop.h
+++ message_loop.h
@@ -299,6 +299,16 @@ class BASE_EXPORT MessageLoop : public MessagePump::Delegate {
@ -46,7 +46,7 @@ index 5b1728e..79c4c58 100644
// Can only be called from the thread that owns the MessageLoop.
bool is_running() const;
@@ -437,6 +447,12 @@ class BASE_EXPORT MessageLoop : public MessagePump::Delegate {
@@ -436,6 +446,12 @@ class BASE_EXPORT MessageLoop : public MessagePump::Delegate {
// insider a (accidentally induced?) nested message pump.
bool nestable_tasks_allowed_;
@ -60,10 +60,10 @@ index 5b1728e..79c4c58 100644
// if type_ is TYPE_CUSTOM and pump_ is null.
MessagePumpFactoryCallback pump_factory_;
diff --git message_pump_win.cc message_pump_win.cc
index b9b2c84..9abef7e 100644
index f1ec727..4b859c0 100644
--- message_pump_win.cc
+++ message_pump_win.cc
@@ -478,20 +478,28 @@ bool MessagePumpForUI::ProcessMessageHelper(const MSG& msg) {
@@ -366,20 +366,28 @@ bool MessagePumpForUI::ProcessMessageHelper(const MSG& msg) {
}
bool MessagePumpForUI::ProcessPumpReplacementMessage() {
@ -88,7 +88,7 @@ index b9b2c84..9abef7e 100644
+ bool have_message = false;
MSG msg;
- const bool have_message =
- g_peek_message(&msg, nullptr, 0, 0, PM_REMOVE) != FALSE;
- PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE) != FALSE;
+ // We should not process all window messages if we are in the context of an
+ // OS modal loop, i.e. in the context of a windows API call like MessageBox.
+ // This is to ensure that these messages are peeked out by the OS modal loop.
@ -102,5 +102,5 @@ index b9b2c84..9abef7e 100644
- // Expect no message or a message different than kMsgHaveWork.
DCHECK(!have_message || kMsgHaveWork != msg.message ||
msg.hwnd != message_hwnd_);
msg.hwnd != message_window_.hwnd());

Some files were not shown because too many files have changed in this diff Show More