chore: bump chromium to 32e0bab929213da1019992bf31d29 (master) (#19488)

This commit is contained in:
Electron Bot 2019-08-02 16:56:46 -07:00 committed by Jeremy Apthorp
parent d0800aa200
commit e959137a4b
112 changed files with 524 additions and 5639 deletions

View file

@ -60,10 +60,9 @@ class BundledDataSource : public content::URLDataSource {
// content::URLDataSource implementation.
std::string GetSource() override { return kChromeUIDevToolsHost; }
void StartDataRequest(
const std::string& path,
const content::ResourceRequestInfo::WebContentsGetter& wc_getter,
const GotDataCallback& callback) override {
void StartDataRequest(const std::string& path,
const content::WebContents::Getter& wc_getter,
const GotDataCallback& callback) override {
// Serve request from local bundle.
std::string bundled_path_prefix(kChromeUIDevToolsBundledPath);
bundled_path_prefix += "/";

View file

@ -1,231 +0,0 @@
// Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/browser/ui/webui/pdf_viewer_handler.h"
#include <memory>
#include <utility>
#include "base/bind.h"
#include "base/values.h"
#include "chrome/browser/browser_process.h"
#include "content/public/browser/stream_handle.h"
#include "content/public/browser/stream_info.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_ui.h"
#include "content/public/common/page_zoom.h"
#include "content/public/common/url_constants.h"
#include "net/http/http_response_headers.h"
#include "shell/common/atom_constants.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/webui/web_ui_util.h"
namespace electron {
namespace {
void CreateResponseHeadersDictionary(const net::HttpResponseHeaders* headers,
base::DictionaryValue* result) {
if (!headers)
return;
size_t iter = 0;
std::string header_name;
std::string header_value;
while (headers->EnumerateHeaderLines(&iter, &header_name, &header_value)) {
base::Value* existing_value = nullptr;
if (result->Get(header_name, &existing_value)) {
std::string src = existing_value->GetString();
result->SetString(header_name, src + ", " + header_value);
} else {
result->SetString(header_name, header_value);
}
}
}
void PopulateStreamInfo(base::DictionaryValue* stream_info,
content::StreamInfo* stream,
const std::string& original_url) {
auto headers_dict = std::make_unique<base::DictionaryValue>();
auto stream_url = stream->handle->GetURL().spec();
CreateResponseHeadersDictionary(stream->response_headers.get(),
headers_dict.get());
stream_info->SetString("streamURL", stream_url);
stream_info->SetString("originalURL", original_url);
stream_info->Set("responseHeaders", std::move(headers_dict));
}
} // namespace
PdfViewerHandler::PdfViewerHandler(const std::string& src)
: original_url_(src) {}
PdfViewerHandler::~PdfViewerHandler() {
RemoveObserver();
}
void PdfViewerHandler::SetPdfResourceStream(content::StreamInfo* stream) {
stream_ = stream;
if (!!initialize_callback_id_.get()) {
auto list = std::make_unique<base::ListValue>();
list->Set(0, std::move(initialize_callback_id_));
Initialize(list.get());
}
}
void PdfViewerHandler::RegisterMessages() {
web_ui()->RegisterMessageCallback(
"initialize", base::BindRepeating(&PdfViewerHandler::Initialize,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getDefaultZoom", base::BindRepeating(&PdfViewerHandler::GetInitialZoom,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getInitialZoom", base::BindRepeating(&PdfViewerHandler::GetInitialZoom,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"setZoom",
base::BindRepeating(&PdfViewerHandler::SetZoom, base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getStrings", base::BindRepeating(&PdfViewerHandler::GetStrings,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"reload",
base::BindRepeating(&PdfViewerHandler::Reload, base::Unretained(this)));
}
void PdfViewerHandler::OnJavascriptAllowed() {
AddObserver();
}
void PdfViewerHandler::OnJavascriptDisallowed() {
RemoveObserver();
}
void PdfViewerHandler::Initialize(const base::ListValue* args) {
CHECK_EQ(1U, args->GetSize());
const base::Value* callback_id;
CHECK(args->Get(0, &callback_id));
if (stream_) {
CHECK(!initialize_callback_id_.get());
AllowJavascript();
auto stream_info = std::make_unique<base::DictionaryValue>();
PopulateStreamInfo(stream_info.get(), stream_, original_url_);
ResolveJavascriptCallback(*callback_id, *stream_info);
} else {
initialize_callback_id_ =
base::Value::ToUniquePtrValue(callback_id.Clone());
}
auto zoom_controller =
WebContentsZoomController::FromWebContents(web_ui()->GetWebContents());
zoom_controller->SetZoomMode(WebContentsZoomController::ZoomMode::MANUAL);
zoom_controller->SetZoomLevel(0);
}
void PdfViewerHandler::GetDefaultZoom(const base::ListValue* args) {
if (!IsJavascriptAllowed())
return;
CHECK_EQ(1U, args->GetSize());
const base::Value* callback_id;
CHECK(args->Get(0, &callback_id));
auto zoom_controller =
WebContentsZoomController::FromWebContents(web_ui()->GetWebContents());
double zoom_level = zoom_controller->GetDefaultZoomLevel();
ResolveJavascriptCallback(
*callback_id, base::Value(content::ZoomLevelToZoomFactor(zoom_level)));
}
void PdfViewerHandler::GetInitialZoom(const base::ListValue* args) {
if (!IsJavascriptAllowed())
return;
CHECK_EQ(1U, args->GetSize());
const base::Value* callback_id;
CHECK(args->Get(0, &callback_id));
auto zoom_controller =
WebContentsZoomController::FromWebContents(web_ui()->GetWebContents());
double zoom_level = zoom_controller->GetZoomLevel();
ResolveJavascriptCallback(
*callback_id, base::Value(content::ZoomLevelToZoomFactor(zoom_level)));
}
void PdfViewerHandler::SetZoom(const base::ListValue* args) {
if (!IsJavascriptAllowed())
return;
CHECK_EQ(2U, args->GetSize());
const base::Value* callback_id;
CHECK(args->Get(0, &callback_id));
double zoom_level = 0.0;
CHECK(args->GetDouble(1, &zoom_level));
auto zoom_controller =
WebContentsZoomController::FromWebContents(web_ui()->GetWebContents());
zoom_controller->SetZoomLevel(zoom_level);
ResolveJavascriptCallback(*callback_id, base::Value(zoom_level));
}
void PdfViewerHandler::GetStrings(const base::ListValue* args) {
if (!IsJavascriptAllowed())
return;
CHECK_EQ(1U, args->GetSize());
const base::Value* callback_id;
CHECK(args->Get(0, &callback_id));
auto result = std::make_unique<base::DictionaryValue>();
// TODO(deepak1556): Generate strings from components/pdf_strings.grdp.
#define SET_STRING(id, resource) result->SetString(id, resource)
SET_STRING("passwordPrompt",
"This document is password protected. Please enter a password.");
SET_STRING("passwordSubmit", "Submit");
SET_STRING("passwordInvalid", "Incorrect password");
SET_STRING("pageLoading", "Loading...");
SET_STRING("pageLoadFailed", "Failed to load PDF document");
SET_STRING("pageReload", "Reload");
SET_STRING("bookmarks", "Bookmarks");
SET_STRING("labelPageNumber", "Page number");
SET_STRING("tooltipRotateCW", "Rotate clockwise");
SET_STRING("tooltipDownload", "Download");
SET_STRING("tooltipFitToPage", "Fit to page");
SET_STRING("tooltipFitToWidth", "Fit to width");
SET_STRING("tooltipZoomIn", "Zoom in");
SET_STRING("tooltipZoomOut", "Zoom out");
#undef SET_STRING
webui::SetLoadTimeDataDefaults(g_browser_process->GetApplicationLocale(),
result.get());
ResolveJavascriptCallback(*callback_id, *result);
}
void PdfViewerHandler::Reload(const base::ListValue* args) {
CHECK_EQ(0U, args->GetSize());
web_ui()->GetWebContents()->ReloadFocusedFrame(false);
}
void PdfViewerHandler::OnZoomLevelChanged(content::WebContents* web_contents,
double level,
bool is_temporary) {
if (web_ui()->GetWebContents() == web_contents) {
CallJavascriptFunction("cr.webUIListenerCallback",
base::Value("onZoomLevelChanged"),
base::Value(content::ZoomLevelToZoomFactor(level)));
}
}
void PdfViewerHandler::AddObserver() {
auto zoom_controller =
WebContentsZoomController::FromWebContents(web_ui()->GetWebContents());
zoom_controller->AddObserver(this);
}
void PdfViewerHandler::RemoveObserver() {
auto zoom_controller =
WebContentsZoomController::FromWebContents(web_ui()->GetWebContents());
zoom_controller->RemoveObserver(this);
}
} // namespace electron

View file

@ -1,61 +0,0 @@
// Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_BROWSER_UI_WEBUI_PDF_VIEWER_HANDLER_H_
#define SHELL_BROWSER_UI_WEBUI_PDF_VIEWER_HANDLER_H_
#include <memory>
#include <string>
#include "base/macros.h"
#include "content/public/browser/host_zoom_map.h"
#include "content/public/browser/web_ui_message_handler.h"
#include "shell/browser/web_contents_zoom_controller.h"
namespace base {
class ListValue;
}
namespace content {
struct StreamInfo;
}
namespace electron {
class PdfViewerHandler : public content::WebUIMessageHandler,
public WebContentsZoomController::Observer {
public:
explicit PdfViewerHandler(const std::string& original_url);
~PdfViewerHandler() override;
void SetPdfResourceStream(content::StreamInfo* stream);
protected:
// WebUIMessageHandler implementation.
void RegisterMessages() override;
void OnJavascriptAllowed() override;
void OnJavascriptDisallowed() override;
private:
void Initialize(const base::ListValue* args);
void GetDefaultZoom(const base::ListValue* args);
void GetInitialZoom(const base::ListValue* args);
void SetZoom(const base::ListValue* args);
void GetStrings(const base::ListValue* args);
void Reload(const base::ListValue* args);
void OnZoomLevelChanged(content::WebContents* web_contents,
double level,
bool is_temporary);
void AddObserver();
void RemoveObserver();
std::unique_ptr<base::Value> initialize_callback_id_;
content::StreamInfo* stream_ = nullptr;
std::string original_url_;
DISALLOW_COPY_AND_ASSIGN(PdfViewerHandler);
};
} // namespace electron
#endif // SHELL_BROWSER_UI_WEBUI_PDF_VIEWER_HANDLER_H_

View file

@ -1,258 +0,0 @@
// Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/browser/ui/webui/pdf_viewer_ui.h"
#include <map>
#include <memory>
#include <utility>
#include "base/sequenced_task_runner_helpers.h"
#include "base/task/post_task.h"
#include "content/browser/loader/resource_dispatcher_host_impl.h"
#include "content/browser/loader/resource_request_info_impl.h"
#include "content/browser/loader/stream_resource_handler.h"
#include "content/browser/resource_context_impl.h"
#include "content/browser/streams/stream.h"
#include "content/browser/streams/stream_context.h"
#include "content/public/browser/browser_task_traits.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/render_view_host.h"
#include "content/public/browser/resource_context.h"
#include "content/public/browser/stream_handle.h"
#include "content/public/browser/stream_info.h"
#include "content/public/browser/url_data_source.h"
#include "content/public/browser/web_contents.h"
#include "grit/pdf_viewer_resources_map.h"
#include "net/base/load_flags.h"
#include "net/base/mime_util.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_context.h"
#include "services/network/public/cpp/resource_response.h"
#include "shell/browser/atom_browser_context.h"
#include "shell/browser/loader/layered_resource_handler.h"
#include "shell/browser/ui/webui/pdf_viewer_handler.h"
#include "shell/common/atom_constants.h"
#include "ui/base/resource/resource_bundle.h"
using content::BrowserThread;
namespace electron {
namespace {
// Extracts the path value from the URL without the leading '/',
// which follows the mapping of names in pdf_viewer_resources_map.
std::string PathWithoutParams(const std::string& path) {
return GURL(kPdfViewerUIOrigin + path).path().substr(1);
}
class BundledDataSource : public content::URLDataSource {
public:
BundledDataSource() {
for (size_t i = 0; i < kPdfViewerResourcesSize; ++i) {
std::string resource_path = kPdfViewerResources[i].name;
DCHECK(path_to_resource_id_.find(resource_path) ==
path_to_resource_id_.end());
path_to_resource_id_[resource_path] = kPdfViewerResources[i].value;
}
}
// content::URLDataSource implementation.
std::string GetSource() const override { return kPdfViewerUIHost; }
void StartDataRequest(
const std::string& path,
const content::ResourceRequestInfo::WebContentsGetter& wc_getter,
const GotDataCallback& callback) override {
std::string filename = PathWithoutParams(path);
auto entry = path_to_resource_id_.find(filename);
if (entry != path_to_resource_id_.end()) {
int resource_id = entry->second;
const ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
callback.Run(rb.LoadDataResourceBytes(resource_id));
} else {
LOG(ERROR) << "Unable to find: " << path;
callback.Run(new base::RefCountedString());
}
}
std::string GetMimeType(const std::string& path) const override {
base::FilePath::StringType ext =
base::FilePath::FromUTF8Unsafe(PathWithoutParams(path)).Extension();
std::string mime_type;
if (!ext.empty() &&
net::GetWellKnownMimeTypeFromExtension(ext.substr(1), &mime_type))
return mime_type;
return "text/html";
}
bool ShouldAddContentSecurityPolicy() const override { return false; }
bool ShouldDenyXFrameOptions() const override { return false; }
bool ShouldServeMimeTypeAsContentTypeHeader() const override { return true; }
private:
~BundledDataSource() override {}
// A map from a resource path to the resource ID.
std::map<std::string, int> path_to_resource_id_;
DISALLOW_COPY_AND_ASSIGN(BundledDataSource);
};
// Helper to convert from OnceCallback to Callback.
template <typename T>
void CallMigrationCallback(T callback,
std::unique_ptr<content::StreamInfo> stream_info) {
std::move(callback).Run(std::move(stream_info));
}
} // namespace
class PdfViewerUI::ResourceRequester
: public base::RefCountedThreadSafe<ResourceRequester,
BrowserThread::DeleteOnIOThread>,
public electron::LayeredResourceHandler::Delegate {
public:
explicit ResourceRequester(StreamResponseCallback cb)
: stream_response_cb_(std::move(cb)) {}
void StartRequest(const GURL& url,
const GURL& origin,
int render_process_id,
int render_view_id,
int render_frame_id,
content::ResourceContext* resource_context) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
const net::URLRequestContext* request_context =
resource_context->GetRequestContext();
std::unique_ptr<net::URLRequest> request(request_context->CreateRequest(
url, net::DEFAULT_PRIORITY, nullptr, MISSING_TRAFFIC_ANNOTATION));
request->set_method("GET");
content::ResourceDispatcherHostImpl::Get()->InitializeURLRequest(
request.get(), content::Referrer(url, blink::kWebReferrerPolicyDefault),
false, // download.
render_process_id, render_view_id, render_frame_id,
content::PREVIEWS_OFF, resource_context);
content::ResourceRequestInfoImpl* info =
content::ResourceRequestInfoImpl::ForRequest(request.get());
content::StreamContext* stream_context =
content::GetStreamContextForResourceContext(resource_context);
std::unique_ptr<content::ResourceHandler> handler =
std::make_unique<content::StreamResourceHandler>(
request.get(), stream_context->registry(), origin, false);
info->set_is_stream(true);
stream_info_.reset(new content::StreamInfo);
stream_info_->handle =
static_cast<content::StreamResourceHandler*>(handler.get())
->stream()
->CreateHandle();
stream_info_->original_url = request->url();
// Helper to fill stream response details.
handler.reset(new electron::LayeredResourceHandler(
request.get(), std::move(handler), this));
content::ResourceDispatcherHostImpl::Get()->BeginURLRequest(
std::move(request), std::move(handler),
false, // download
false, // content_initiated (download specific)
false, // do_not_prompt_for_login (download specific)
resource_context);
}
protected:
// electron::LayeredResourceHandler::Delegate:
void OnResponseStarted(network::ResourceResponse* response) override {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
auto resource_response_head = response->head;
auto headers = resource_response_head.headers;
auto mime_type = resource_response_head.mime_type;
if (headers.get())
stream_info_->response_headers =
new net::HttpResponseHeaders(headers->raw_headers());
stream_info_->mime_type = mime_type;
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::UI},
base::BindOnce(&CallMigrationCallback<StreamResponseCallback>,
base::Passed(&stream_response_cb_),
base::Passed(&stream_info_)));
}
private:
friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
friend class base::DeleteHelper<ResourceRequester>;
~ResourceRequester() override {}
StreamResponseCallback stream_response_cb_;
std::unique_ptr<content::StreamInfo> stream_info_;
DISALLOW_COPY_AND_ASSIGN(ResourceRequester);
};
PdfViewerUI::PdfViewerUI(content::BrowserContext* browser_context,
content::WebUI* web_ui,
const std::string& src)
: content::WebUIController(web_ui),
content::WebContentsObserver(web_ui->GetWebContents()),
src_(src) {
pdf_handler_ = new PdfViewerHandler(src);
web_ui->AddMessageHandler(
std::unique_ptr<content::WebUIMessageHandler>(pdf_handler_));
content::URLDataSource::Add(browser_context, new BundledDataSource);
}
PdfViewerUI::~PdfViewerUI() {}
bool PdfViewerUI::OnMessageReceived(
const IPC::Message& message,
content::RenderFrameHost* render_frame_host) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(PdfViewerUI, message)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void PdfViewerUI::OnPdfStreamCreated(
std::unique_ptr<content::StreamInfo> stream) {
stream_ = std::move(stream);
if (pdf_handler_)
pdf_handler_->SetPdfResourceStream(stream_.get());
resource_requester_ = nullptr;
}
void PdfViewerUI::RenderFrameCreated(content::RenderFrameHost* rfh) {
int render_process_id = rfh->GetProcess()->GetID();
int render_frame_id = rfh->GetRoutingID();
int render_view_id = rfh->GetRenderViewHost()->GetRoutingID();
auto resource_context =
web_contents()->GetBrowserContext()->GetResourceContext();
auto callback =
base::BindOnce(&PdfViewerUI::OnPdfStreamCreated, base::Unretained(this));
resource_requester_ = new ResourceRequester(std::move(callback));
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO},
base::BindOnce(&ResourceRequester::StartRequest, resource_requester_,
GURL(src_), GURL(kPdfViewerUIOrigin), render_process_id,
render_view_id, render_frame_id, resource_context));
}
void PdfViewerUI::OnSaveURLAs(const GURL& url,
const content::Referrer& referrer) {
web_contents()->SaveFrame(url, referrer);
}
} // namespace electron

View file

@ -1,61 +0,0 @@
// Copyright (c) 2017 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_BROWSER_UI_WEBUI_PDF_VIEWER_UI_H_
#define SHELL_BROWSER_UI_WEBUI_PDF_VIEWER_UI_H_
#include <memory>
#include <string>
#include "base/macros.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/browser/web_ui_controller.h"
#include "ipc/ipc_message.h"
namespace content {
class BrowserContext;
struct StreamInfo;
} // namespace content
namespace electron {
class PdfViewerHandler;
class PdfViewerUI : public content::WebUIController,
public content::WebContentsObserver {
public:
PdfViewerUI(content::BrowserContext* browser_context,
content::WebUI* web_ui,
const std::string& src);
~PdfViewerUI() override;
// content::WebContentsObserver:
bool OnMessageReceived(const IPC::Message& message,
content::RenderFrameHost* render_frame_host) override;
void RenderFrameCreated(content::RenderFrameHost* rfh) override;
private:
using StreamResponseCallback =
base::OnceCallback<void(std::unique_ptr<content::StreamInfo>)>;
class ResourceRequester;
void OnPdfStreamCreated(std::unique_ptr<content::StreamInfo> stream_info);
void OnSaveURLAs(const GURL& url, const content::Referrer& referrer);
// Source URL from where the PDF originates.
std::string src_;
PdfViewerHandler* pdf_handler_;
scoped_refptr<ResourceRequester> resource_requester_;
// Pdf Resource stream.
std::unique_ptr<content::StreamInfo> stream_;
DISALLOW_COPY_AND_ASSIGN(PdfViewerUI);
};
} // namespace electron
#endif // SHELL_BROWSER_UI_WEBUI_PDF_VIEWER_UI_H_