The Blink Rename
This commit is contained in:
Aleksei Kuzmin
parent
3939359354
commit
7a4ca08a8d
32 changed files with 452 additions and 450 deletions
|
|
@ -590,8 +590,8 @@ bool WebContents::PreHandleKeyboardEvent(
|
|||
content::WebContents* source,
|
||||
const content::NativeWebKeyboardEvent& event,
|
||||
bool* is_keyboard_shortcut) {
|
||||
if (event.type() == blink::WebInputEvent::Type::RawKeyDown ||
|
||||
event.type() == blink::WebInputEvent::Type::KeyUp) {
|
||||
if (event.GetType() == blink::WebInputEvent::Type::kRawKeyDown ||
|
||||
event.GetType() == blink::WebInputEvent::Type::kKeyUp) {
|
||||
return Emit("before-input-event", event);
|
||||
} else {
|
||||
return false;
|
||||
|
|
@ -818,7 +818,7 @@ void WebContents::DidFinishNavigation(
|
|||
bool is_main_frame = navigation_handle->IsInMainFrame();
|
||||
if (navigation_handle->HasCommitted() && !navigation_handle->IsErrorPage()) {
|
||||
auto url = navigation_handle->GetURL();
|
||||
bool is_in_page = navigation_handle->IsSamePage();
|
||||
bool is_in_page = navigation_handle->IsSameDocument();
|
||||
if (is_main_frame && !is_in_page) {
|
||||
Emit("did-navigate", url);
|
||||
} else if (is_in_page) {
|
||||
|
|
@ -1002,7 +1002,7 @@ void WebContents::LoadURL(const GURL& url, const mate::Dictionary& options) {
|
|||
GURL http_referrer;
|
||||
if (options.Get("httpReferrer", &http_referrer))
|
||||
params.referrer = content::Referrer(http_referrer.GetAsReferrer(),
|
||||
blink::WebReferrerPolicyDefault);
|
||||
blink::kWebReferrerPolicyDefault);
|
||||
|
||||
std::string user_agent;
|
||||
if (options.Get("userAgent", &user_agent))
|
||||
|
|
@ -1426,22 +1426,22 @@ void WebContents::SendInputEvent(v8::Isolate* isolate,
|
|||
return;
|
||||
|
||||
int type = mate::GetWebInputEventType(isolate, input_event);
|
||||
if (blink::WebInputEvent::isMouseEventType(type)) {
|
||||
if (blink::WebInputEvent::IsMouseEventType(type)) {
|
||||
blink::WebMouseEvent mouse_event;
|
||||
if (mate::ConvertFromV8(isolate, input_event, &mouse_event)) {
|
||||
view->ProcessMouseEvent(mouse_event, ui::LatencyInfo());
|
||||
return;
|
||||
}
|
||||
} else if (blink::WebInputEvent::isKeyboardEventType(type)) {
|
||||
} else if (blink::WebInputEvent::IsKeyboardEventType(type)) {
|
||||
content::NativeWebKeyboardEvent keyboard_event(
|
||||
blink::WebKeyboardEvent::RawKeyDown,
|
||||
blink::WebInputEvent::NoModifiers,
|
||||
blink::WebKeyboardEvent::kRawKeyDown,
|
||||
blink::WebInputEvent::kNoModifiers,
|
||||
ui::EventTimeForNow());
|
||||
if (mate::ConvertFromV8(isolate, input_event, &keyboard_event)) {
|
||||
view->ProcessKeyboardEvent(keyboard_event);
|
||||
return;
|
||||
}
|
||||
} else if (type == blink::WebInputEvent::MouseWheel) {
|
||||
} else if (type == blink::WebInputEvent::kMouseWheel) {
|
||||
blink::WebMouseWheelEvent mouse_wheel_event;
|
||||
if (mate::ConvertFromV8(isolate, input_event, &mouse_wheel_event)) {
|
||||
view->ProcessMouseWheelEvent(mouse_wheel_event, ui::LatencyInfo());
|
||||
|
|
|
|||
|
|
@ -20,11 +20,11 @@ void CommonWebContentsDelegate::HandleKeyboardEvent(
|
|||
content::WebContents* source,
|
||||
const content::NativeWebKeyboardEvent& event) {
|
||||
if (event.skip_in_browser ||
|
||||
event.type() == content::NativeWebKeyboardEvent::Char)
|
||||
event.GetType() == content::NativeWebKeyboardEvent::kChar)
|
||||
return;
|
||||
|
||||
// Escape exits tabbed fullscreen mode.
|
||||
if (event.windowsKeyCode == ui::VKEY_ESCAPE && is_html_fullscreen())
|
||||
if (event.windows_key_code == ui::VKEY_ESCAPE && is_html_fullscreen())
|
||||
ExitFullscreenModeForTab(source);
|
||||
|
||||
if (!ignore_menu_shortcuts_) {
|
||||
|
|
|
|||
|
|
@ -1604,10 +1604,10 @@ void NativeWindowMac::SetEscapeTouchBarItem(const mate::PersistentDictionary& it
|
|||
}
|
||||
|
||||
void NativeWindowMac::OnInputEvent(const blink::WebInputEvent& event) {
|
||||
switch (event.type()) {
|
||||
case blink::WebInputEvent::GestureScrollBegin:
|
||||
case blink::WebInputEvent::GestureScrollUpdate:
|
||||
case blink::WebInputEvent::GestureScrollEnd:
|
||||
switch (event.GetType()) {
|
||||
case blink::WebInputEvent::kGestureScrollBegin:
|
||||
case blink::WebInputEvent::kGestureScrollUpdate:
|
||||
case blink::WebInputEvent::kGestureScrollEnd:
|
||||
this->NotifyWindowScrollTouchEdge();
|
||||
break;
|
||||
default:
|
||||
|
|
|
|||
|
|
@ -43,23 +43,23 @@ const int kFrameRetryLimit = 2;
|
|||
|
||||
ui::MouseEvent UiMouseEventFromWebMouseEvent(blink::WebMouseEvent event) {
|
||||
ui::EventType type = ui::EventType::ET_UNKNOWN;
|
||||
switch (event.type()) {
|
||||
case blink::WebInputEvent::MouseDown:
|
||||
switch (event.GetType()) {
|
||||
case blink::WebInputEvent::kMouseDown:
|
||||
type = ui::EventType::ET_MOUSE_PRESSED;
|
||||
break;
|
||||
case blink::WebInputEvent::MouseUp:
|
||||
case blink::WebInputEvent::kMouseUp:
|
||||
type = ui::EventType::ET_MOUSE_RELEASED;
|
||||
break;
|
||||
case blink::WebInputEvent::MouseMove:
|
||||
case blink::WebInputEvent::kMouseMove:
|
||||
type = ui::EventType::ET_MOUSE_MOVED;
|
||||
break;
|
||||
case blink::WebInputEvent::MouseEnter:
|
||||
case blink::WebInputEvent::kMouseEnter:
|
||||
type = ui::EventType::ET_MOUSE_ENTERED;
|
||||
break;
|
||||
case blink::WebInputEvent::MouseLeave:
|
||||
case blink::WebInputEvent::kMouseLeave:
|
||||
type = ui::EventType::ET_MOUSE_EXITED;
|
||||
break;
|
||||
case blink::WebInputEvent::MouseWheel:
|
||||
case blink::WebInputEvent::kMouseWheel:
|
||||
type = ui::EventType::ET_MOUSEWHEEL;
|
||||
break;
|
||||
default:
|
||||
|
|
@ -69,19 +69,19 @@ ui::MouseEvent UiMouseEventFromWebMouseEvent(blink::WebMouseEvent event) {
|
|||
|
||||
int button_flags = 0;
|
||||
switch (event.button) {
|
||||
case blink::WebMouseEvent::Button::X1:
|
||||
case blink::WebMouseEvent::Button::kBack:
|
||||
button_flags |= ui::EventFlags::EF_BACK_MOUSE_BUTTON;
|
||||
break;
|
||||
case blink::WebMouseEvent::Button::X2:
|
||||
case blink::WebMouseEvent::Button::kForward:
|
||||
button_flags |= ui::EventFlags::EF_FORWARD_MOUSE_BUTTON;
|
||||
break;
|
||||
case blink::WebMouseEvent::Button::Left:
|
||||
case blink::WebMouseEvent::Button::kLeft:
|
||||
button_flags |= ui::EventFlags::EF_LEFT_MOUSE_BUTTON;
|
||||
break;
|
||||
case blink::WebMouseEvent::Button::Middle:
|
||||
case blink::WebMouseEvent::Button::kMiddle:
|
||||
button_flags |= ui::EventFlags::EF_MIDDLE_MOUSE_BUTTON;
|
||||
break;
|
||||
case blink::WebMouseEvent::Button::Right:
|
||||
case blink::WebMouseEvent::Button::kRight:
|
||||
button_flags |= ui::EventFlags::EF_RIGHT_MOUSE_BUTTON;
|
||||
break;
|
||||
default:
|
||||
|
|
@ -94,7 +94,7 @@ ui::MouseEvent UiMouseEventFromWebMouseEvent(blink::WebMouseEvent event) {
|
|||
gfx::Point(std::floor(event.x), std::floor(event.y)),
|
||||
ui::EventTimeForNow(),
|
||||
button_flags, button_flags);
|
||||
ui_event.SetClickCount(event.clickCount);
|
||||
ui_event.SetClickCount(event.click_count);
|
||||
|
||||
return ui_event;
|
||||
}
|
||||
|
|
@ -102,7 +102,7 @@ ui::MouseEvent UiMouseEventFromWebMouseEvent(blink::WebMouseEvent event) {
|
|||
ui::MouseWheelEvent UiMouseWheelEventFromWebMouseEvent(
|
||||
blink::WebMouseWheelEvent event) {
|
||||
return ui::MouseWheelEvent(UiMouseEventFromWebMouseEvent(event),
|
||||
std::floor(event.deltaX), std::floor(event.deltaY));
|
||||
std::floor(event.delta_x), std::floor(event.delta_y));
|
||||
}
|
||||
|
||||
#if !defined(OS_MACOSX)
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ class OffScreenRenderWidgetHostView
|
|||
void OnProxyViewPaint(const gfx::Rect& damage_rect);
|
||||
|
||||
bool IsPopupWidget() const {
|
||||
return popup_type_ != blink::WebPopupTypeNone;
|
||||
return popup_type_ != blink::kWebPopupTypeNone;
|
||||
}
|
||||
|
||||
void HoldResize();
|
||||
|
|
|
|||
|
|
@ -132,7 +132,7 @@ class PdfViewerUI::ResourceRequester
|
|||
request->set_method("GET");
|
||||
|
||||
content::ResourceDispatcherHostImpl::Get()->InitializeURLRequest(
|
||||
request.get(), content::Referrer(url, blink::WebReferrerPolicyDefault),
|
||||
request.get(), content::Referrer(url, blink::kWebReferrerPolicyDefault),
|
||||
false, // download.
|
||||
render_process_id, render_view_id, render_frame_id,
|
||||
content::PREVIEWS_OFF, resource_context);
|
||||
|
|
|
|||
|
|
@ -19,11 +19,11 @@ namespace atom {
|
|||
namespace {
|
||||
|
||||
content::RenderView* GetCurrentRenderView() {
|
||||
WebLocalFrame* frame = WebLocalFrame::frameForCurrentContext();
|
||||
WebLocalFrame* frame = WebLocalFrame::FrameForCurrentContext();
|
||||
if (!frame)
|
||||
return nullptr;
|
||||
|
||||
WebView* view = frame->view();
|
||||
WebView* view = frame->View();
|
||||
if (!view)
|
||||
return nullptr; // can happen during closing.
|
||||
|
||||
|
|
|
|||
|
|
@ -179,27 +179,27 @@ ui::KeyboardCode KeyboardCodeFromStr(const std::string& str, bool* shifted) {
|
|||
int WebEventModifiersToEventFlags(int modifiers) {
|
||||
int flags = 0;
|
||||
|
||||
if (modifiers & blink::WebInputEvent::ShiftKey)
|
||||
if (modifiers & blink::WebInputEvent::kShiftKey)
|
||||
flags |= ui::EF_SHIFT_DOWN;
|
||||
if (modifiers & blink::WebInputEvent::ControlKey)
|
||||
if (modifiers & blink::WebInputEvent::kControlKey)
|
||||
flags |= ui::EF_CONTROL_DOWN;
|
||||
if (modifiers & blink::WebInputEvent::AltKey)
|
||||
if (modifiers & blink::WebInputEvent::kAltKey)
|
||||
flags |= ui::EF_ALT_DOWN;
|
||||
if (modifiers & blink::WebInputEvent::MetaKey)
|
||||
if (modifiers & blink::WebInputEvent::kMetaKey)
|
||||
flags |= ui::EF_COMMAND_DOWN;
|
||||
if (modifiers & blink::WebInputEvent::CapsLockOn)
|
||||
if (modifiers & blink::WebInputEvent::kCapsLockOn)
|
||||
flags |= ui::EF_CAPS_LOCK_ON;
|
||||
if (modifiers & blink::WebInputEvent::NumLockOn)
|
||||
if (modifiers & blink::WebInputEvent::kNumLockOn)
|
||||
flags |= ui::EF_NUM_LOCK_ON;
|
||||
if (modifiers & blink::WebInputEvent::ScrollLockOn)
|
||||
if (modifiers & blink::WebInputEvent::kScrollLockOn)
|
||||
flags |= ui::EF_SCROLL_LOCK_ON;
|
||||
if (modifiers & blink::WebInputEvent::LeftButtonDown)
|
||||
if (modifiers & blink::WebInputEvent::kLeftButtonDown)
|
||||
flags |= ui::EF_LEFT_MOUSE_BUTTON;
|
||||
if (modifiers & blink::WebInputEvent::MiddleButtonDown)
|
||||
if (modifiers & blink::WebInputEvent::kMiddleButtonDown)
|
||||
flags |= ui::EF_MIDDLE_MOUSE_BUTTON;
|
||||
if (modifiers & blink::WebInputEvent::RightButtonDown)
|
||||
if (modifiers & blink::WebInputEvent::kRightButtonDown)
|
||||
flags |= ui::EF_RIGHT_MOUSE_BUTTON;
|
||||
if (modifiers & blink::WebInputEvent::IsAutoRepeat)
|
||||
if (modifiers & blink::WebInputEvent::kIsAutoRepeat)
|
||||
flags |= ui::EF_IS_REPEAT;
|
||||
|
||||
return flags;
|
||||
|
|
|
|||
|
|
@ -11,50 +11,50 @@ namespace atom {
|
|||
|
||||
std::string CursorTypeToString(const content::WebCursor::CursorInfo& info) {
|
||||
switch (info.type) {
|
||||
case Cursor::TypePointer: return "default";
|
||||
case Cursor::TypeCross: return "crosshair";
|
||||
case Cursor::TypeHand: return "pointer";
|
||||
case Cursor::TypeIBeam: return "text";
|
||||
case Cursor::TypeWait: return "wait";
|
||||
case Cursor::TypeHelp: return "help";
|
||||
case Cursor::TypeEastResize: return "e-resize";
|
||||
case Cursor::TypeNorthResize: return "n-resize";
|
||||
case Cursor::TypeNorthEastResize: return "ne-resize";
|
||||
case Cursor::TypeNorthWestResize: return "nw-resize";
|
||||
case Cursor::TypeSouthResize: return "s-resize";
|
||||
case Cursor::TypeSouthEastResize: return "se-resize";
|
||||
case Cursor::TypeSouthWestResize: return "sw-resize";
|
||||
case Cursor::TypeWestResize: return "w-resize";
|
||||
case Cursor::TypeNorthSouthResize: return "ns-resize";
|
||||
case Cursor::TypeEastWestResize: return "ew-resize";
|
||||
case Cursor::TypeNorthEastSouthWestResize: return "nesw-resize";
|
||||
case Cursor::TypeNorthWestSouthEastResize: return "nwse-resize";
|
||||
case Cursor::TypeColumnResize: return "col-resize";
|
||||
case Cursor::TypeRowResize: return "row-resize";
|
||||
case Cursor::TypeMiddlePanning: return "m-panning";
|
||||
case Cursor::TypeEastPanning: return "e-panning";
|
||||
case Cursor::TypeNorthPanning: return "n-panning";
|
||||
case Cursor::TypeNorthEastPanning: return "ne-panning";
|
||||
case Cursor::TypeNorthWestPanning: return "nw-panning";
|
||||
case Cursor::TypeSouthPanning: return "s-panning";
|
||||
case Cursor::TypeSouthEastPanning: return "se-panning";
|
||||
case Cursor::TypeSouthWestPanning: return "sw-panning";
|
||||
case Cursor::TypeWestPanning: return "w-panning";
|
||||
case Cursor::TypeMove: return "move";
|
||||
case Cursor::TypeVerticalText: return "vertical-text";
|
||||
case Cursor::TypeCell: return "cell";
|
||||
case Cursor::TypeContextMenu: return "context-menu";
|
||||
case Cursor::TypeAlias: return "alias";
|
||||
case Cursor::TypeProgress: return "progress";
|
||||
case Cursor::TypeNoDrop: return "nodrop";
|
||||
case Cursor::TypeCopy: return "copy";
|
||||
case Cursor::TypeNone: return "none";
|
||||
case Cursor::TypeNotAllowed: return "not-allowed";
|
||||
case Cursor::TypeZoomIn: return "zoom-in";
|
||||
case Cursor::TypeZoomOut: return "zoom-out";
|
||||
case Cursor::TypeGrab: return "grab";
|
||||
case Cursor::TypeGrabbing: return "grabbing";
|
||||
case Cursor::TypeCustom: return "custom";
|
||||
case Cursor::kTypePointer: return "default";
|
||||
case Cursor::kTypeCross: return "crosshair";
|
||||
case Cursor::kTypeHand: return "pointer";
|
||||
case Cursor::kTypeIBeam: return "text";
|
||||
case Cursor::kTypeWait: return "wait";
|
||||
case Cursor::kTypeHelp: return "help";
|
||||
case Cursor::kTypeEastResize: return "e-resize";
|
||||
case Cursor::kTypeNorthResize: return "n-resize";
|
||||
case Cursor::kTypeNorthEastResize: return "ne-resize";
|
||||
case Cursor::kTypeNorthWestResize: return "nw-resize";
|
||||
case Cursor::kTypeSouthResize: return "s-resize";
|
||||
case Cursor::kTypeSouthEastResize: return "se-resize";
|
||||
case Cursor::kTypeSouthWestResize: return "sw-resize";
|
||||
case Cursor::kTypeWestResize: return "w-resize";
|
||||
case Cursor::kTypeNorthSouthResize: return "ns-resize";
|
||||
case Cursor::kTypeEastWestResize: return "ew-resize";
|
||||
case Cursor::kTypeNorthEastSouthWestResize: return "nesw-resize";
|
||||
case Cursor::kTypeNorthWestSouthEastResize: return "nwse-resize";
|
||||
case Cursor::kTypeColumnResize: return "col-resize";
|
||||
case Cursor::kTypeRowResize: return "row-resize";
|
||||
case Cursor::kTypeMiddlePanning: return "m-panning";
|
||||
case Cursor::kTypeEastPanning: return "e-panning";
|
||||
case Cursor::kTypeNorthPanning: return "n-panning";
|
||||
case Cursor::kTypeNorthEastPanning: return "ne-panning";
|
||||
case Cursor::kTypeNorthWestPanning: return "nw-panning";
|
||||
case Cursor::kTypeSouthPanning: return "s-panning";
|
||||
case Cursor::kTypeSouthEastPanning: return "se-panning";
|
||||
case Cursor::kTypeSouthWestPanning: return "sw-panning";
|
||||
case Cursor::kTypeWestPanning: return "w-panning";
|
||||
case Cursor::kTypeMove: return "move";
|
||||
case Cursor::kTypeVerticalText: return "vertical-text";
|
||||
case Cursor::kTypeCell: return "cell";
|
||||
case Cursor::kTypeContextMenu: return "context-menu";
|
||||
case Cursor::kTypeAlias: return "alias";
|
||||
case Cursor::kTypeProgress: return "progress";
|
||||
case Cursor::kTypeNoDrop: return "nodrop";
|
||||
case Cursor::kTypeCopy: return "copy";
|
||||
case Cursor::kTypeNone: return "none";
|
||||
case Cursor::kTypeNotAllowed: return "not-allowed";
|
||||
case Cursor::kTypeZoomIn: return "zoom-in";
|
||||
case Cursor::kTypeZoomOut: return "zoom-out";
|
||||
case Cursor::kTypeGrab: return "grab";
|
||||
case Cursor::kTypeGrabbing: return "grabbing";
|
||||
case Cursor::kTypeCustom: return "custom";
|
||||
default: return "default";
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -54,33 +54,33 @@ struct Converter<blink::WebInputEvent::Type> {
|
|||
blink::WebInputEvent::Type* out) {
|
||||
std::string type = base::ToLowerASCII(V8ToString(val));
|
||||
if (type == "mousedown")
|
||||
*out = blink::WebInputEvent::MouseDown;
|
||||
*out = blink::WebInputEvent::kMouseDown;
|
||||
else if (type == "mouseup")
|
||||
*out = blink::WebInputEvent::MouseUp;
|
||||
*out = blink::WebInputEvent::kMouseUp;
|
||||
else if (type == "mousemove")
|
||||
*out = blink::WebInputEvent::MouseMove;
|
||||
*out = blink::WebInputEvent::kMouseMove;
|
||||
else if (type == "mouseenter")
|
||||
*out = blink::WebInputEvent::MouseEnter;
|
||||
*out = blink::WebInputEvent::kMouseEnter;
|
||||
else if (type == "mouseleave")
|
||||
*out = blink::WebInputEvent::MouseLeave;
|
||||
*out = blink::WebInputEvent::kMouseLeave;
|
||||
else if (type == "contextmenu")
|
||||
*out = blink::WebInputEvent::ContextMenu;
|
||||
*out = blink::WebInputEvent::kContextMenu;
|
||||
else if (type == "mousewheel")
|
||||
*out = blink::WebInputEvent::MouseWheel;
|
||||
*out = blink::WebInputEvent::kMouseWheel;
|
||||
else if (type == "keydown")
|
||||
*out = blink::WebInputEvent::RawKeyDown;
|
||||
*out = blink::WebInputEvent::kRawKeyDown;
|
||||
else if (type == "keyup")
|
||||
*out = blink::WebInputEvent::KeyUp;
|
||||
*out = blink::WebInputEvent::kKeyUp;
|
||||
else if (type == "char")
|
||||
*out = blink::WebInputEvent::Char;
|
||||
*out = blink::WebInputEvent::kChar;
|
||||
else if (type == "touchstart")
|
||||
*out = blink::WebInputEvent::TouchStart;
|
||||
*out = blink::WebInputEvent::kTouchStart;
|
||||
else if (type == "touchmove")
|
||||
*out = blink::WebInputEvent::TouchMove;
|
||||
*out = blink::WebInputEvent::kTouchMove;
|
||||
else if (type == "touchend")
|
||||
*out = blink::WebInputEvent::TouchEnd;
|
||||
*out = blink::WebInputEvent::kTouchEnd;
|
||||
else if (type == "touchcancel")
|
||||
*out = blink::WebInputEvent::TouchCancel;
|
||||
*out = blink::WebInputEvent::kTouchCancel;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
|
@ -91,11 +91,11 @@ struct Converter<blink::WebMouseEvent::Button> {
|
|||
blink::WebMouseEvent::Button* out) {
|
||||
std::string button = base::ToLowerASCII(V8ToString(val));
|
||||
if (button == "left")
|
||||
*out = blink::WebMouseEvent::Button::Left;
|
||||
*out = blink::WebMouseEvent::Button::kLeft;
|
||||
else if (button == "middle")
|
||||
*out = blink::WebMouseEvent::Button::Middle;
|
||||
*out = blink::WebMouseEvent::Button::kMiddle;
|
||||
else if (button == "right")
|
||||
*out = blink::WebMouseEvent::Button::Right;
|
||||
*out = blink::WebMouseEvent::Button::kRight;
|
||||
else
|
||||
return false;
|
||||
return true;
|
||||
|
|
@ -108,37 +108,37 @@ struct Converter<blink::WebInputEvent::Modifiers> {
|
|||
blink::WebInputEvent::Modifiers* out) {
|
||||
std::string modifier = base::ToLowerASCII(V8ToString(val));
|
||||
if (modifier == "shift")
|
||||
*out = blink::WebInputEvent::ShiftKey;
|
||||
*out = blink::WebInputEvent::kShiftKey;
|
||||
else if (modifier == "control" || modifier == "ctrl")
|
||||
*out = blink::WebInputEvent::ControlKey;
|
||||
*out = blink::WebInputEvent::kControlKey;
|
||||
else if (modifier == "alt")
|
||||
*out = blink::WebInputEvent::AltKey;
|
||||
*out = blink::WebInputEvent::kAltKey;
|
||||
else if (modifier == "meta" || modifier == "command" || modifier == "cmd")
|
||||
*out = blink::WebInputEvent::MetaKey;
|
||||
*out = blink::WebInputEvent::kMetaKey;
|
||||
else if (modifier == "iskeypad")
|
||||
*out = blink::WebInputEvent::IsKeyPad;
|
||||
*out = blink::WebInputEvent::kIsKeyPad;
|
||||
else if (modifier == "isautorepeat")
|
||||
*out = blink::WebInputEvent::IsAutoRepeat;
|
||||
*out = blink::WebInputEvent::kIsAutoRepeat;
|
||||
else if (modifier == "leftbuttondown")
|
||||
*out = blink::WebInputEvent::LeftButtonDown;
|
||||
*out = blink::WebInputEvent::kLeftButtonDown;
|
||||
else if (modifier == "middlebuttondown")
|
||||
*out = blink::WebInputEvent::MiddleButtonDown;
|
||||
*out = blink::WebInputEvent::kMiddleButtonDown;
|
||||
else if (modifier == "rightbuttondown")
|
||||
*out = blink::WebInputEvent::RightButtonDown;
|
||||
*out = blink::WebInputEvent::kRightButtonDown;
|
||||
else if (modifier == "capslock")
|
||||
*out = blink::WebInputEvent::CapsLockOn;
|
||||
*out = blink::WebInputEvent::kCapsLockOn;
|
||||
else if (modifier == "numlock")
|
||||
*out = blink::WebInputEvent::NumLockOn;
|
||||
*out = blink::WebInputEvent::kNumLockOn;
|
||||
else if (modifier == "left")
|
||||
*out = blink::WebInputEvent::IsLeft;
|
||||
*out = blink::WebInputEvent::kIsLeft;
|
||||
else if (modifier == "right")
|
||||
*out = blink::WebInputEvent::IsRight;
|
||||
*out = blink::WebInputEvent::kIsRight;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
int GetWebInputEventType(v8::Isolate* isolate, v8::Local<v8::Value> val) {
|
||||
blink::WebInputEvent::Type type = blink::WebInputEvent::Undefined;
|
||||
blink::WebInputEvent::Type type = blink::WebInputEvent::kUndefined;
|
||||
mate::Dictionary dict;
|
||||
ConvertFromV8(isolate, val, &dict) && dict.Get("type", &type);
|
||||
return type;
|
||||
|
|
@ -153,11 +153,11 @@ bool Converter<blink::WebInputEvent>::FromV8(
|
|||
blink::WebInputEvent::Type type;
|
||||
if (!dict.Get("type", &type))
|
||||
return false;
|
||||
out->setType(type);
|
||||
out->SetType(type);
|
||||
std::vector<blink::WebInputEvent::Modifiers> modifiers;
|
||||
if (dict.Get("modifiers", &modifiers))
|
||||
out->setModifiers(VectorToBitArray(modifiers));
|
||||
out->setTimeStampSeconds(base::Time::Now().ToDoubleT());
|
||||
out->SetModifiers(VectorToBitArray(modifiers));
|
||||
out->SetTimeStampSeconds(base::Time::Now().ToDoubleT());
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -176,31 +176,31 @@ bool Converter<blink::WebKeyboardEvent>::FromV8(
|
|||
|
||||
bool shifted = false;
|
||||
ui::KeyboardCode keyCode = atom::KeyboardCodeFromStr(str, &shifted);
|
||||
out->windowsKeyCode = keyCode;
|
||||
out->windows_key_code = keyCode;
|
||||
if (shifted)
|
||||
out->setModifiers(out->modifiers() | blink::WebInputEvent::ShiftKey);
|
||||
out->SetModifiers(out->GetModifiers() | blink::WebInputEvent::kShiftKey);
|
||||
|
||||
ui::DomCode domCode = ui::UsLayoutKeyboardCodeToDomCode(keyCode);
|
||||
out->domCode = static_cast<int>(domCode);
|
||||
out->dom_code = static_cast<int>(domCode);
|
||||
|
||||
ui::DomKey domKey;
|
||||
ui::KeyboardCode dummy_code;
|
||||
int flags = atom::WebEventModifiersToEventFlags(out->modifiers());
|
||||
int flags = atom::WebEventModifiersToEventFlags(out->GetModifiers());
|
||||
if (ui::DomCodeToUsLayoutDomKey(domCode, flags, &domKey, &dummy_code))
|
||||
out->domKey = static_cast<int>(domKey);
|
||||
out->dom_key = static_cast<int>(domKey);
|
||||
|
||||
if ((out->type() == blink::WebInputEvent::Char ||
|
||||
out->type() == blink::WebInputEvent::RawKeyDown)) {
|
||||
if ((out->GetType() == blink::WebInputEvent::kChar ||
|
||||
out->GetType() == blink::WebInputEvent::kRawKeyDown)) {
|
||||
// Make sure to not read beyond the buffer in case some bad code doesn't
|
||||
// NULL-terminate it (this is called from plugins).
|
||||
size_t text_length_cap = blink::WebKeyboardEvent::textLengthCap;
|
||||
size_t text_length_cap = blink::WebKeyboardEvent::kTextLengthCap;
|
||||
base::string16 text16 = base::UTF8ToUTF16(str);
|
||||
|
||||
memset(out->text, 0, text_length_cap);
|
||||
memset(out->unmodifiedText, 0, text_length_cap);
|
||||
memset(out->unmodified_text, 0, text_length_cap);
|
||||
for (size_t i = 0; i < std::min(text_length_cap, text16.size()); ++i) {
|
||||
out->text[i] = text16[i];
|
||||
out->unmodifiedText[i] = text16[i];
|
||||
out->unmodified_text[i] = text16[i];
|
||||
}
|
||||
}
|
||||
return true;
|
||||
|
|
@ -222,20 +222,20 @@ v8::Local<v8::Value> Converter<content::NativeWebKeyboardEvent>::ToV8(
|
|||
v8::Isolate* isolate, const content::NativeWebKeyboardEvent& in) {
|
||||
mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
|
||||
|
||||
if (in.type() == blink::WebInputEvent::Type::RawKeyDown)
|
||||
if (in.GetType() == blink::WebInputEvent::Type::kRawKeyDown)
|
||||
dict.Set("type", "keyDown");
|
||||
else if (in.type() == blink::WebInputEvent::Type::KeyUp)
|
||||
else if (in.GetType() == blink::WebInputEvent::Type::kKeyUp)
|
||||
dict.Set("type", "keyUp");
|
||||
dict.Set("key", ui::KeycodeConverter::DomKeyToKeyString(in.domKey));
|
||||
dict.Set("key", ui::KeycodeConverter::DomKeyToKeyString(in.dom_key));
|
||||
dict.Set("code", ui::KeycodeConverter::DomCodeToCodeString(
|
||||
static_cast<ui::DomCode>(in.domCode)));
|
||||
static_cast<ui::DomCode>(in.dom_code)));
|
||||
|
||||
using Modifiers = blink::WebInputEvent::Modifiers;
|
||||
dict.Set("isAutoRepeat", (in.modifiers() & Modifiers::IsAutoRepeat) != 0);
|
||||
dict.Set("shift", (in.modifiers() & Modifiers::ShiftKey) != 0);
|
||||
dict.Set("control", (in.modifiers() & Modifiers::ControlKey) != 0);
|
||||
dict.Set("alt", (in.modifiers() & Modifiers::AltKey) != 0);
|
||||
dict.Set("meta", (in.modifiers() & Modifiers::MetaKey) != 0);
|
||||
dict.Set("isAutoRepeat", (in.GetModifiers() & Modifiers::kIsAutoRepeat) != 0);
|
||||
dict.Set("shift", (in.GetModifiers() & Modifiers::kShiftKey) != 0);
|
||||
dict.Set("control", (in.GetModifiers() & Modifiers::kControlKey) != 0);
|
||||
dict.Set("alt", (in.GetModifiers() & Modifiers::kAltKey) != 0);
|
||||
dict.Set("meta", (in.GetModifiers() & Modifiers::kMetaKey) != 0);
|
||||
|
||||
return dict.GetHandle();
|
||||
}
|
||||
|
|
@ -250,12 +250,12 @@ bool Converter<blink::WebMouseEvent>::FromV8(
|
|||
if (!dict.Get("x", &out->x) || !dict.Get("y", &out->y))
|
||||
return false;
|
||||
if (!dict.Get("button", &out->button))
|
||||
out->button = blink::WebMouseEvent::Button::Left;
|
||||
out->button = blink::WebMouseEvent::Button::kLeft;
|
||||
dict.Get("globalX", &out->globalX);
|
||||
dict.Get("globalY", &out->globalY);
|
||||
dict.Get("movementX", &out->movementX);
|
||||
dict.Get("movementY", &out->movementY);
|
||||
dict.Get("clickCount", &out->clickCount);
|
||||
dict.Get("movementX", &out->movement_x);
|
||||
dict.Get("movementY", &out->movement_y);
|
||||
dict.Get("clickCount", &out->click_count);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -267,20 +267,20 @@ bool Converter<blink::WebMouseWheelEvent>::FromV8(
|
|||
return false;
|
||||
if (!ConvertFromV8(isolate, val, static_cast<blink::WebMouseEvent*>(out)))
|
||||
return false;
|
||||
dict.Get("deltaX", &out->deltaX);
|
||||
dict.Get("deltaY", &out->deltaY);
|
||||
dict.Get("wheelTicksX", &out->wheelTicksX);
|
||||
dict.Get("wheelTicksY", &out->wheelTicksY);
|
||||
dict.Get("accelerationRatioX", &out->accelerationRatioX);
|
||||
dict.Get("accelerationRatioY", &out->accelerationRatioY);
|
||||
dict.Get("hasPreciseScrollingDeltas", &out->hasPreciseScrollingDeltas);
|
||||
dict.Get("deltaX", &out->delta_x);
|
||||
dict.Get("deltaY", &out->delta_y);
|
||||
dict.Get("wheelTicksX", &out->wheel_ticks_x);
|
||||
dict.Get("wheelTicksY", &out->wheel_ticks_y);
|
||||
dict.Get("accelerationRatioX", &out->acceleration_ratio_x);
|
||||
dict.Get("accelerationRatioY", &out->acceleration_ratio_y);
|
||||
dict.Get("hasPreciseScrollingDeltas", &out->has_precise_scrolling_deltas);
|
||||
|
||||
#if defined(USE_AURA)
|
||||
// Matches the behavior of ui/events/blink/web_input_event_traits.cc:
|
||||
bool can_scroll = true;
|
||||
if (dict.Get("canScroll", &can_scroll) && !can_scroll) {
|
||||
out->hasPreciseScrollingDeltas = false;
|
||||
out->setModifiers(out->modifiers() & ~blink::WebInputEvent::ControlKey);
|
||||
out->has_precise_scrolling_deltas = false;
|
||||
out->setModifiers(out->GetModifiers() & ~blink::WebInputEvent::ControlKey);
|
||||
}
|
||||
#endif
|
||||
return true;
|
||||
|
|
@ -321,18 +321,18 @@ bool Converter<blink::WebDeviceEmulationParams>::FromV8(
|
|||
if (dict.Get("screenPosition", &screen_position)) {
|
||||
screen_position = base::ToLowerASCII(screen_position);
|
||||
if (screen_position == "mobile")
|
||||
out->screenPosition = blink::WebDeviceEmulationParams::Mobile;
|
||||
out->screen_position = blink::WebDeviceEmulationParams::kMobile;
|
||||
else if (screen_position == "desktop")
|
||||
out->screenPosition = blink::WebDeviceEmulationParams::Desktop;
|
||||
out->screen_position = blink::WebDeviceEmulationParams::kDesktop;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
dict.Get("screenSize", &out->screenSize);
|
||||
dict.Get("viewPosition", &out->viewPosition);
|
||||
dict.Get("deviceScaleFactor", &out->deviceScaleFactor);
|
||||
dict.Get("viewSize", &out->viewSize);
|
||||
dict.Get("fitToView", &out->fitToView);
|
||||
dict.Get("screenSize", &out->screen_size);
|
||||
dict.Get("viewPosition", &out->view_position);
|
||||
dict.Get("deviceScaleFactor", &out->device_scale_factor);
|
||||
dict.Get("viewSize", &out->view_size);
|
||||
dict.Get("fitToView", &out->fit_to_view);
|
||||
dict.Get("offset", &out->offset);
|
||||
dict.Get("scale", &out->scale);
|
||||
return true;
|
||||
|
|
@ -347,10 +347,10 @@ bool Converter<blink::WebFindOptions>::FromV8(
|
|||
return false;
|
||||
|
||||
dict.Get("forward", &out->forward);
|
||||
dict.Get("matchCase", &out->matchCase);
|
||||
dict.Get("findNext", &out->findNext);
|
||||
dict.Get("wordStart", &out->wordStart);
|
||||
dict.Get("medialCapitalAsWordStart", &out->medialCapitalAsWordStart);
|
||||
dict.Get("matchCase", &out->match_case);
|
||||
dict.Get("findNext", &out->find_next);
|
||||
dict.Get("wordStart", &out->word_start);
|
||||
dict.Get("medialCapitalAsWordStart", &out->medial_capital_as_word_start);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -358,17 +358,17 @@ bool Converter<blink::WebFindOptions>::FromV8(
|
|||
v8::Local<v8::Value> Converter<blink::WebContextMenuData::MediaType>::ToV8(
|
||||
v8::Isolate* isolate, const blink::WebContextMenuData::MediaType& in) {
|
||||
switch (in) {
|
||||
case blink::WebContextMenuData::MediaTypeImage:
|
||||
case blink::WebContextMenuData::kMediaTypeImage:
|
||||
return mate::StringToV8(isolate, "image");
|
||||
case blink::WebContextMenuData::MediaTypeVideo:
|
||||
case blink::WebContextMenuData::kMediaTypeVideo:
|
||||
return mate::StringToV8(isolate, "video");
|
||||
case blink::WebContextMenuData::MediaTypeAudio:
|
||||
case blink::WebContextMenuData::kMediaTypeAudio:
|
||||
return mate::StringToV8(isolate, "audio");
|
||||
case blink::WebContextMenuData::MediaTypeCanvas:
|
||||
case blink::WebContextMenuData::kMediaTypeCanvas:
|
||||
return mate::StringToV8(isolate, "canvas");
|
||||
case blink::WebContextMenuData::MediaTypeFile:
|
||||
case blink::WebContextMenuData::kMediaTypeFile:
|
||||
return mate::StringToV8(isolate, "file");
|
||||
case blink::WebContextMenuData::MediaTypePlugin:
|
||||
case blink::WebContextMenuData::kMediaTypePlugin:
|
||||
return mate::StringToV8(isolate, "plugin");
|
||||
default:
|
||||
return mate::StringToV8(isolate, "none");
|
||||
|
|
@ -380,11 +380,11 @@ v8::Local<v8::Value> Converter<blink::WebContextMenuData::InputFieldType>::ToV8(
|
|||
v8::Isolate* isolate,
|
||||
const blink::WebContextMenuData::InputFieldType& in) {
|
||||
switch (in) {
|
||||
case blink::WebContextMenuData::InputFieldTypePlainText:
|
||||
case blink::WebContextMenuData::kInputFieldTypePlainText:
|
||||
return mate::StringToV8(isolate, "plainText");
|
||||
case blink::WebContextMenuData::InputFieldTypePassword:
|
||||
case blink::WebContextMenuData::kInputFieldTypePassword:
|
||||
return mate::StringToV8(isolate, "password");
|
||||
case blink::WebContextMenuData::InputFieldTypeOther:
|
||||
case blink::WebContextMenuData::kInputFieldTypeOther:
|
||||
return mate::StringToV8(isolate, "other");
|
||||
default:
|
||||
return mate::StringToV8(isolate, "none");
|
||||
|
|
@ -394,16 +394,16 @@ v8::Local<v8::Value> Converter<blink::WebContextMenuData::InputFieldType>::ToV8(
|
|||
v8::Local<v8::Value> EditFlagsToV8(v8::Isolate* isolate, int editFlags) {
|
||||
mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
|
||||
dict.Set("canUndo",
|
||||
!!(editFlags & blink::WebContextMenuData::CanUndo));
|
||||
!!(editFlags & blink::WebContextMenuData::kCanUndo));
|
||||
dict.Set("canRedo",
|
||||
!!(editFlags & blink::WebContextMenuData::CanRedo));
|
||||
!!(editFlags & blink::WebContextMenuData::kCanRedo));
|
||||
dict.Set("canCut",
|
||||
!!(editFlags & blink::WebContextMenuData::CanCut));
|
||||
!!(editFlags & blink::WebContextMenuData::kCanCut));
|
||||
dict.Set("canCopy",
|
||||
!!(editFlags & blink::WebContextMenuData::CanCopy));
|
||||
!!(editFlags & blink::WebContextMenuData::kCanCopy));
|
||||
|
||||
bool pasteFlag = false;
|
||||
if (editFlags & blink::WebContextMenuData::CanPaste) {
|
||||
if (editFlags & blink::WebContextMenuData::kCanPaste) {
|
||||
std::vector<base::string16> types;
|
||||
bool ignore;
|
||||
ui::Clipboard::GetForCurrentThread()->ReadAvailableTypes(
|
||||
|
|
@ -413,9 +413,9 @@ v8::Local<v8::Value> EditFlagsToV8(v8::Isolate* isolate, int editFlags) {
|
|||
dict.Set("canPaste", pasteFlag);
|
||||
|
||||
dict.Set("canDelete",
|
||||
!!(editFlags & blink::WebContextMenuData::CanDelete));
|
||||
!!(editFlags & blink::WebContextMenuData::kCanDelete));
|
||||
dict.Set("canSelectAll",
|
||||
!!(editFlags & blink::WebContextMenuData::CanSelectAll));
|
||||
!!(editFlags & blink::WebContextMenuData::kCanSelectAll));
|
||||
|
||||
return mate::ConvertToV8(isolate, dict);
|
||||
}
|
||||
|
|
@ -423,21 +423,21 @@ v8::Local<v8::Value> EditFlagsToV8(v8::Isolate* isolate, int editFlags) {
|
|||
v8::Local<v8::Value> MediaFlagsToV8(v8::Isolate* isolate, int mediaFlags) {
|
||||
mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
|
||||
dict.Set("inError",
|
||||
!!(mediaFlags & blink::WebContextMenuData::MediaInError));
|
||||
!!(mediaFlags & blink::WebContextMenuData::kMediaInError));
|
||||
dict.Set("isPaused",
|
||||
!!(mediaFlags & blink::WebContextMenuData::MediaPaused));
|
||||
!!(mediaFlags & blink::WebContextMenuData::kMediaPaused));
|
||||
dict.Set("isMuted",
|
||||
!!(mediaFlags & blink::WebContextMenuData::MediaMuted));
|
||||
!!(mediaFlags & blink::WebContextMenuData::kMediaMuted));
|
||||
dict.Set("hasAudio",
|
||||
!!(mediaFlags & blink::WebContextMenuData::MediaHasAudio));
|
||||
!!(mediaFlags & blink::WebContextMenuData::kMediaHasAudio));
|
||||
dict.Set("isLooping",
|
||||
(mediaFlags & blink::WebContextMenuData::MediaLoop) != 0);
|
||||
(mediaFlags & blink::WebContextMenuData::kMediaLoop) != 0);
|
||||
dict.Set("isControlsVisible",
|
||||
(mediaFlags & blink::WebContextMenuData::MediaControls) != 0);
|
||||
(mediaFlags & blink::WebContextMenuData::kMediaControls) != 0);
|
||||
dict.Set("canToggleControls",
|
||||
!!(mediaFlags & blink::WebContextMenuData::MediaCanToggleControls));
|
||||
!!(mediaFlags & blink::WebContextMenuData::kMediaCanToggleControls));
|
||||
dict.Set("canRotate",
|
||||
!!(mediaFlags & blink::WebContextMenuData::MediaCanRotate));
|
||||
!!(mediaFlags & blink::WebContextMenuData::kMediaCanRotate));
|
||||
return mate::ConvertToV8(isolate, dict);
|
||||
}
|
||||
|
||||
|
|
@ -447,7 +447,7 @@ v8::Local<v8::Value> Converter<blink::WebCache::ResourceTypeStat>::ToV8(
|
|||
mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
|
||||
dict.Set("count", static_cast<uint32_t>(stat.count));
|
||||
dict.Set("size", static_cast<double>(stat.size));
|
||||
dict.Set("liveSize", static_cast<double>(stat.decodedSize));
|
||||
dict.Set("liveSize", static_cast<double>(stat.decoded_size));
|
||||
return dict.GetHandle();
|
||||
}
|
||||
|
||||
|
|
@ -457,8 +457,8 @@ v8::Local<v8::Value> Converter<blink::WebCache::ResourceTypeStats>::ToV8(
|
|||
mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);
|
||||
dict.Set("images", stats.images);
|
||||
dict.Set("scripts", stats.scripts);
|
||||
dict.Set("cssStyleSheets", stats.cssStyleSheets);
|
||||
dict.Set("xslStyleSheets", stats.xslStyleSheets);
|
||||
dict.Set("cssStyleSheets", stats.css_style_sheets);
|
||||
dict.Set("xslStyleSheets", stats.xsl_style_sheets);
|
||||
dict.Set("fonts", stats.fonts);
|
||||
dict.Set("other", stats.other);
|
||||
return dict.GetHandle();
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ v8::Local<v8::Value> Converter<ContextMenuParamsWithWebContents>::ToV8(
|
|||
dict.Set("mediaType", params.media_type);
|
||||
dict.Set("mediaFlags", MediaFlagsToV8(isolate, params.media_flags));
|
||||
bool has_image_contents =
|
||||
(params.media_type == blink::WebContextMenuData::MediaTypeImage) &&
|
||||
(params.media_type == blink::WebContextMenuData::kMediaTypeImage) &&
|
||||
params.has_image_contents;
|
||||
dict.Set("hasImageContents", has_image_contents);
|
||||
dict.Set("isEditable", params.is_editable);
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@ namespace atom {
|
|||
namespace api {
|
||||
|
||||
RenderView* GetCurrentRenderView() {
|
||||
WebLocalFrame* frame = WebLocalFrame::frameForCurrentContext();
|
||||
WebLocalFrame* frame = WebLocalFrame::FrameForCurrentContext();
|
||||
if (!frame)
|
||||
return nullptr;
|
||||
|
||||
WebView* view = frame->view();
|
||||
WebView* view = frame->View();
|
||||
if (!view)
|
||||
return nullptr; // can happen during closing.
|
||||
|
||||
|
|
|
|||
|
|
@ -51,41 +51,41 @@ SpellCheckClient::SpellCheckClient(const std::string& language,
|
|||
|
||||
SpellCheckClient::~SpellCheckClient() {}
|
||||
|
||||
void SpellCheckClient::checkSpelling(
|
||||
void SpellCheckClient::CheckSpelling(
|
||||
const blink::WebString& text,
|
||||
int& misspelling_start,
|
||||
int& misspelling_len,
|
||||
blink::WebVector<blink::WebString>* optional_suggestions) {
|
||||
std::vector<blink::WebTextCheckingResult> results;
|
||||
SpellCheckText(text.utf16(), true, &results);
|
||||
SpellCheckText(text.Utf16(), true, &results);
|
||||
if (results.size() == 1) {
|
||||
misspelling_start = results[0].location;
|
||||
misspelling_len = results[0].length;
|
||||
}
|
||||
}
|
||||
|
||||
void SpellCheckClient::requestCheckingOfText(
|
||||
void SpellCheckClient::RequestCheckingOfText(
|
||||
const blink::WebString& textToCheck,
|
||||
blink::WebTextCheckingCompletion* completionCallback) {
|
||||
base::string16 text(textToCheck.utf16());
|
||||
base::string16 text(textToCheck.Utf16());
|
||||
if (text.empty() || !HasWordCharacters(text, 0)) {
|
||||
completionCallback->didCancelCheckingText();
|
||||
completionCallback->DidCancelCheckingText();
|
||||
return;
|
||||
}
|
||||
|
||||
std::vector<blink::WebTextCheckingResult> results;
|
||||
SpellCheckText(text, false, &results);
|
||||
completionCallback->didFinishCheckingText(results);
|
||||
completionCallback->DidFinishCheckingText(results);
|
||||
}
|
||||
|
||||
void SpellCheckClient::showSpellingUI(bool show) {
|
||||
void SpellCheckClient::ShowSpellingUI(bool show) {
|
||||
}
|
||||
|
||||
bool SpellCheckClient::isShowingSpellingUI() {
|
||||
bool SpellCheckClient::IsShowingSpellingUI() {
|
||||
return false;
|
||||
}
|
||||
|
||||
void SpellCheckClient::updateSpellingUIWithMisspelledWord(
|
||||
void SpellCheckClient::UpdateSpellingUIWithMisspelledWord(
|
||||
const blink::WebString& word) {
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -31,17 +31,17 @@ class SpellCheckClient : public blink::WebSpellCheckClient {
|
|||
|
||||
private:
|
||||
// blink::WebSpellCheckClient:
|
||||
void checkSpelling(
|
||||
void CheckSpelling(
|
||||
const blink::WebString& text,
|
||||
int& misspelledOffset,
|
||||
int& misspelledLength,
|
||||
blink::WebVector<blink::WebString>* optionalSuggestions) override;
|
||||
void requestCheckingOfText(
|
||||
void RequestCheckingOfText(
|
||||
const blink::WebString& textToCheck,
|
||||
blink::WebTextCheckingCompletion* completionCallback) override;
|
||||
void showSpellingUI(bool show) override;
|
||||
bool isShowingSpellingUI() override;
|
||||
void updateSpellingUIWithMisspelledWord(
|
||||
void ShowSpellingUI(bool show) override;
|
||||
bool IsShowingSpellingUI() override;
|
||||
void UpdateSpellingUIWithMisspelledWord(
|
||||
const blink::WebString& word) override;
|
||||
|
||||
// Check the spelling of text.
|
||||
|
|
|
|||
|
|
@ -44,9 +44,9 @@ class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
|
|||
: callback_(callback) {}
|
||||
~ScriptExecutionCallback() override {}
|
||||
|
||||
void completed(
|
||||
void Completed(
|
||||
const blink::WebVector<v8::Local<v8::Value>>& result) override {
|
||||
if (!callback_.is_null() && !result.isEmpty() && !result[0].IsEmpty())
|
||||
if (!callback_.is_null() && !result.IsEmpty() && !result[0].IsEmpty())
|
||||
// Right now only single results per frame is supported.
|
||||
callback_.Run(result[0]);
|
||||
delete this;
|
||||
|
|
@ -61,7 +61,7 @@ class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
|
|||
} // namespace
|
||||
|
||||
WebFrame::WebFrame(v8::Isolate* isolate)
|
||||
: web_frame_(blink::WebLocalFrame::frameForCurrentContext()) {
|
||||
: web_frame_(blink::WebLocalFrame::FrameForCurrentContext()) {
|
||||
Init(isolate);
|
||||
}
|
||||
|
||||
|
|
@ -69,13 +69,13 @@ WebFrame::~WebFrame() {
|
|||
}
|
||||
|
||||
void WebFrame::SetName(const std::string& name) {
|
||||
web_frame_->setName(blink::WebString::fromUTF8(name));
|
||||
web_frame_->SetName(blink::WebString::FromUTF8(name));
|
||||
}
|
||||
|
||||
double WebFrame::SetZoomLevel(double level) {
|
||||
double result = 0.0;
|
||||
content::RenderView* render_view =
|
||||
content::RenderView::FromWebView(web_frame_->view());
|
||||
content::RenderView::FromWebView(web_frame_->View());
|
||||
render_view->Send(new AtomViewHostMsg_SetTemporaryZoomLevel(
|
||||
render_view->GetRoutingID(), level, &result));
|
||||
return result;
|
||||
|
|
@ -84,34 +84,34 @@ double WebFrame::SetZoomLevel(double level) {
|
|||
double WebFrame::GetZoomLevel() const {
|
||||
double result = 0.0;
|
||||
content::RenderView* render_view =
|
||||
content::RenderView::FromWebView(web_frame_->view());
|
||||
content::RenderView::FromWebView(web_frame_->View());
|
||||
render_view->Send(
|
||||
new AtomViewHostMsg_GetZoomLevel(render_view->GetRoutingID(), &result));
|
||||
return result;
|
||||
}
|
||||
|
||||
double WebFrame::SetZoomFactor(double factor) {
|
||||
return blink::WebView::zoomLevelToZoomFactor(SetZoomLevel(
|
||||
blink::WebView::zoomFactorToZoomLevel(factor)));
|
||||
return blink::WebView::ZoomLevelToZoomFactor(SetZoomLevel(
|
||||
blink::WebView::ZoomFactorToZoomLevel(factor)));
|
||||
}
|
||||
|
||||
double WebFrame::GetZoomFactor() const {
|
||||
return blink::WebView::zoomLevelToZoomFactor(GetZoomLevel());
|
||||
return blink::WebView::ZoomLevelToZoomFactor(GetZoomLevel());
|
||||
}
|
||||
|
||||
void WebFrame::SetVisualZoomLevelLimits(double min_level, double max_level) {
|
||||
web_frame_->view()->setDefaultPageScaleLimits(min_level, max_level);
|
||||
web_frame_->View()->SetDefaultPageScaleLimits(min_level, max_level);
|
||||
}
|
||||
|
||||
void WebFrame::SetLayoutZoomLevelLimits(double min_level, double max_level) {
|
||||
web_frame_->view()->zoomLimitsChanged(min_level, max_level);
|
||||
web_frame_->View()->ZoomLimitsChanged(min_level, max_level);
|
||||
}
|
||||
|
||||
v8::Local<v8::Value> WebFrame::RegisterEmbedderCustomElement(
|
||||
const base::string16& name, v8::Local<v8::Object> options) {
|
||||
blink::WebExceptionCode c = 0;
|
||||
return web_frame_->document().registerEmbedderCustomElement(
|
||||
blink::WebString::fromUTF16(name), options, c);
|
||||
return web_frame_->GetDocument().RegisterEmbedderCustomElement(
|
||||
blink::WebString::FromUTF16(name), options, c);
|
||||
}
|
||||
|
||||
void WebFrame::RegisterElementResizeCallback(
|
||||
|
|
@ -141,19 +141,19 @@ void WebFrame::SetSpellCheckProvider(mate::Arguments* args,
|
|||
|
||||
spell_check_client_.reset(new SpellCheckClient(
|
||||
language, auto_spell_correct_turned_on, args->isolate(), provider));
|
||||
web_frame_->view()->setSpellCheckClient(spell_check_client_.get());
|
||||
web_frame_->View()->SetSpellCheckClient(spell_check_client_.get());
|
||||
}
|
||||
|
||||
void WebFrame::RegisterURLSchemeAsSecure(const std::string& scheme) {
|
||||
// TODO(pfrazee): Remove 2.0
|
||||
blink::SchemeRegistry::registerURLSchemeAsSecure(
|
||||
WTF::String::fromUTF8(scheme.data(), scheme.length()));
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsSecure(
|
||||
WTF::String::FromUTF8(scheme.data(), scheme.length()));
|
||||
}
|
||||
|
||||
void WebFrame::RegisterURLSchemeAsBypassingCSP(const std::string& scheme) {
|
||||
// Register scheme to bypass pages's Content Security Policy.
|
||||
blink::SchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(
|
||||
WTF::String::fromUTF8(scheme.data(), scheme.length()));
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsBypassingContentSecurityPolicy(
|
||||
WTF::String::FromUTF8(scheme.data(), scheme.length()));
|
||||
}
|
||||
|
||||
void WebFrame::RegisterURLSchemeAsPrivileged(const std::string& scheme,
|
||||
|
|
@ -176,39 +176,39 @@ void WebFrame::RegisterURLSchemeAsPrivileged(const std::string& scheme,
|
|||
}
|
||||
// Register scheme to privileged list (https, wss, data, chrome-extension)
|
||||
WTF::String privileged_scheme(
|
||||
WTF::String::fromUTF8(scheme.data(), scheme.length()));
|
||||
WTF::String::FromUTF8(scheme.data(), scheme.length()));
|
||||
if (secure) {
|
||||
// TODO(pfrazee): Remove 2.0
|
||||
blink::SchemeRegistry::registerURLSchemeAsSecure(privileged_scheme);
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsSecure(privileged_scheme);
|
||||
}
|
||||
if (bypassCSP) {
|
||||
blink::SchemeRegistry::registerURLSchemeAsBypassingContentSecurityPolicy(
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsBypassingContentSecurityPolicy(
|
||||
privileged_scheme);
|
||||
}
|
||||
if (allowServiceWorkers) {
|
||||
blink::SchemeRegistry::registerURLSchemeAsAllowingServiceWorkers(
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsAllowingServiceWorkers(
|
||||
privileged_scheme);
|
||||
}
|
||||
if (supportFetchAPI) {
|
||||
blink::SchemeRegistry::registerURLSchemeAsSupportingFetchAPI(
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsSupportingFetchAPI(
|
||||
privileged_scheme);
|
||||
}
|
||||
if (corsEnabled) {
|
||||
blink::SchemeRegistry::registerURLSchemeAsCORSEnabled(privileged_scheme);
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsCORSEnabled(privileged_scheme);
|
||||
}
|
||||
}
|
||||
|
||||
void WebFrame::InsertText(const std::string& text) {
|
||||
web_frame_->frameWidget()
|
||||
->getActiveWebInputMethodController()
|
||||
->commitText(blink::WebString::fromUTF8(text),
|
||||
web_frame_->FrameWidget()
|
||||
->GetActiveWebInputMethodController()
|
||||
->CommitText(blink::WebString::FromUTF8(text),
|
||||
blink::WebVector<blink::WebCompositionUnderline>(),
|
||||
blink::WebRange(),
|
||||
0);
|
||||
}
|
||||
|
||||
void WebFrame::InsertCSS(const std::string& css) {
|
||||
web_frame_->document().insertStyleSheet(blink::WebString::fromUTF8(css));
|
||||
web_frame_->GetDocument().InsertStyleSheet(blink::WebString::FromUTF8(css));
|
||||
}
|
||||
|
||||
void WebFrame::ExecuteJavaScript(const base::string16& code,
|
||||
|
|
@ -219,8 +219,8 @@ void WebFrame::ExecuteJavaScript(const base::string16& code,
|
|||
args->GetNext(&completion_callback);
|
||||
std::unique_ptr<blink::WebScriptExecutionCallback> callback(
|
||||
new ScriptExecutionCallback(completion_callback));
|
||||
web_frame_->requestExecuteScriptAndReturnValue(
|
||||
blink::WebScriptSource(blink::WebString::fromUTF16(code)),
|
||||
web_frame_->RequestExecuteScriptAndReturnValue(
|
||||
blink::WebScriptSource(blink::WebString::FromUTF16(code)),
|
||||
has_user_gesture,
|
||||
callback.release());
|
||||
}
|
||||
|
|
@ -233,13 +233,13 @@ mate::Handle<WebFrame> WebFrame::Create(v8::Isolate* isolate) {
|
|||
blink::WebCache::ResourceTypeStats WebFrame::GetResourceUsage(
|
||||
v8::Isolate* isolate) {
|
||||
blink::WebCache::ResourceTypeStats stats;
|
||||
blink::WebCache::getResourceTypeStats(&stats);
|
||||
blink::WebCache::GetResourceTypeStats(&stats);
|
||||
return stats;
|
||||
}
|
||||
|
||||
void WebFrame::ClearCache(v8::Isolate* isolate) {
|
||||
isolate->IdleNotificationDeadline(0.5);
|
||||
blink::WebCache::clear();
|
||||
blink::WebCache::Clear();
|
||||
base::MemoryPressureListener::NotifyMemoryPressure(
|
||||
base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,10 +27,10 @@ const size_t kMaxListSize = 512;
|
|||
void GetDataListSuggestions(const blink::WebInputElement& element,
|
||||
std::vector<base::string16>* values,
|
||||
std::vector<base::string16>* labels) {
|
||||
for (const auto& option : element.filteredDataListOptions()) {
|
||||
values->push_back(option.value().utf16());
|
||||
if (option.value() != option.label())
|
||||
labels->push_back(option.label().utf16());
|
||||
for (const auto& option : element.FilteredDataListOptions()) {
|
||||
values->push_back(option.Value().Utf16());
|
||||
if (option.Value() != option.Label())
|
||||
labels->push_back(option.Label().Utf16());
|
||||
else
|
||||
labels->push_back(base::string16());
|
||||
}
|
||||
|
|
@ -56,7 +56,7 @@ AutofillAgent::AutofillAgent(
|
|||
focused_node_was_last_clicked_(false),
|
||||
was_focused_before_now_(false),
|
||||
weak_ptr_factory_(this) {
|
||||
render_frame()->GetWebFrame()->setAutofillClient(this);
|
||||
render_frame()->GetWebFrame()->SetAutofillClient(this);
|
||||
}
|
||||
|
||||
void AutofillAgent::OnDestruct() {
|
||||
|
|
@ -73,34 +73,34 @@ void AutofillAgent::FocusedNodeChanged(const blink::WebNode&) {
|
|||
HidePopup();
|
||||
}
|
||||
|
||||
void AutofillAgent::textFieldDidEndEditing(
|
||||
void AutofillAgent::TextFieldDidEndEditing(
|
||||
const blink::WebInputElement&) {
|
||||
HidePopup();
|
||||
}
|
||||
|
||||
void AutofillAgent::textFieldDidChange(
|
||||
void AutofillAgent::TextFieldDidChange(
|
||||
const blink::WebFormControlElement& element) {
|
||||
if (!IsUserGesture() && !render_frame()->IsPasting())
|
||||
return;
|
||||
|
||||
weak_ptr_factory_.InvalidateWeakPtrs();
|
||||
base::ThreadTaskRunnerHandle::Get()->PostTask(
|
||||
FROM_HERE, base::Bind(&AutofillAgent::textFieldDidChangeImpl,
|
||||
FROM_HERE, base::Bind(&AutofillAgent::TextFieldDidChangeImpl,
|
||||
weak_ptr_factory_.GetWeakPtr(), element));
|
||||
}
|
||||
|
||||
void AutofillAgent::textFieldDidChangeImpl(
|
||||
void AutofillAgent::TextFieldDidChangeImpl(
|
||||
const blink::WebFormControlElement& element) {
|
||||
ShowSuggestionsOptions options;
|
||||
options.requires_caret_at_end = true;
|
||||
ShowSuggestions(element, options);
|
||||
}
|
||||
|
||||
void AutofillAgent::textFieldDidReceiveKeyDown(
|
||||
void AutofillAgent::TextFieldDidReceiveKeyDown(
|
||||
const blink::WebInputElement& element,
|
||||
const blink::WebKeyboardEvent& event) {
|
||||
if (event.windowsKeyCode == ui::VKEY_DOWN ||
|
||||
event.windowsKeyCode == ui::VKEY_UP) {
|
||||
if (event.windows_key_code == ui::VKEY_DOWN ||
|
||||
event.windows_key_code == ui::VKEY_UP) {
|
||||
ShowSuggestionsOptions options;
|
||||
options.autofill_on_empty_values = true;
|
||||
options.requires_caret_at_end = true;
|
||||
|
|
@ -108,16 +108,16 @@ void AutofillAgent::textFieldDidReceiveKeyDown(
|
|||
}
|
||||
}
|
||||
|
||||
void AutofillAgent::openTextDataListChooser(
|
||||
void AutofillAgent::OpenTextDataListChooser(
|
||||
const blink::WebInputElement& element) {
|
||||
ShowSuggestionsOptions options;
|
||||
options.autofill_on_empty_values = true;
|
||||
ShowSuggestions(element, options);
|
||||
}
|
||||
|
||||
void AutofillAgent::dataListOptionsChanged(
|
||||
void AutofillAgent::DataListOptionsChanged(
|
||||
const blink::WebInputElement& element) {
|
||||
if (!element.focused())
|
||||
if (!element.Focused())
|
||||
return;
|
||||
|
||||
ShowSuggestionsOptions options;
|
||||
|
|
@ -133,20 +133,20 @@ AutofillAgent::ShowSuggestionsOptions::ShowSuggestionsOptions()
|
|||
void AutofillAgent::ShowSuggestions(
|
||||
const blink::WebFormControlElement& element,
|
||||
const ShowSuggestionsOptions& options) {
|
||||
if (!element.isEnabled() || element.isReadOnly())
|
||||
if (!element.IsEnabled() || element.IsReadOnly())
|
||||
return;
|
||||
const blink::WebInputElement* input_element = toWebInputElement(&element);
|
||||
const blink::WebInputElement* input_element = ToWebInputElement(&element);
|
||||
if (input_element) {
|
||||
if (!input_element->isTextField())
|
||||
if (!input_element->IsTextField())
|
||||
return;
|
||||
}
|
||||
|
||||
blink::WebString value = element.editingValue();
|
||||
blink::WebString value = element.EditingValue();
|
||||
if (value.length() > kMaxDataLength ||
|
||||
(!options.autofill_on_empty_values && value.isEmpty()) ||
|
||||
(!options.autofill_on_empty_values && value.IsEmpty()) ||
|
||||
(options.requires_caret_at_end &&
|
||||
(element.selectionStart() != element.selectionEnd() ||
|
||||
element.selectionEnd() != static_cast<int>(value.length())))) {
|
||||
(element.SelectionStart() != element.SelectionEnd() ||
|
||||
element.SelectionEnd() != static_cast<int>(value.length())))) {
|
||||
HidePopup();
|
||||
return;
|
||||
}
|
||||
|
|
@ -169,7 +169,7 @@ AutofillAgent::Helper::Helper(AutofillAgent* agent)
|
|||
}
|
||||
|
||||
void AutofillAgent::Helper::OnMouseDown(const blink::WebNode& node) {
|
||||
agent_->focused_node_was_last_clicked_ = !node.isNull() && node.focused();
|
||||
agent_->focused_node_was_last_clicked_ = !node.IsNull() && node.Focused();
|
||||
}
|
||||
|
||||
void AutofillAgent::Helper::FocusChangeComplete() {
|
||||
|
|
@ -188,7 +188,7 @@ bool AutofillAgent::OnMessageReceived(const IPC::Message& message) {
|
|||
}
|
||||
|
||||
bool AutofillAgent::IsUserGesture() const {
|
||||
return blink::WebUserGestureIndicator::isProcessingUserGesture();
|
||||
return blink::WebUserGestureIndicator::IsProcessingUserGesture();
|
||||
}
|
||||
|
||||
void AutofillAgent::HidePopup() {
|
||||
|
|
@ -206,22 +206,22 @@ void AutofillAgent::ShowPopup(
|
|||
}
|
||||
|
||||
void AutofillAgent::OnAcceptSuggestion(base::string16 suggestion) {
|
||||
auto element = render_frame()->GetWebFrame()->document().focusedElement();
|
||||
if (element.isFormControlElement()) {
|
||||
toWebInputElement(&element)->setSuggestedValue(
|
||||
blink::WebString::fromUTF16(suggestion));
|
||||
auto element = render_frame()->GetWebFrame()->GetDocument().FocusedElement();
|
||||
if (element.IsFormControlElement()) {
|
||||
ToWebInputElement(&element)->SetSuggestedValue(
|
||||
blink::WebString::FromUTF16(suggestion));
|
||||
}
|
||||
}
|
||||
|
||||
void AutofillAgent::DoFocusChangeComplete() {
|
||||
auto element = render_frame()->GetWebFrame()->document().focusedElement();
|
||||
if (element.isNull() || !element.isFormControlElement())
|
||||
auto element = render_frame()->GetWebFrame()->GetDocument().FocusedElement();
|
||||
if (element.IsNull() || !element.IsFormControlElement())
|
||||
return;
|
||||
|
||||
if (focused_node_was_last_clicked_ && was_focused_before_now_) {
|
||||
ShowSuggestionsOptions options;
|
||||
options.autofill_on_empty_values = true;
|
||||
auto input_element = toWebInputElement(&element);
|
||||
auto input_element = ToWebInputElement(&element);
|
||||
if (input_element)
|
||||
ShowSuggestions(*input_element, options);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -52,13 +52,13 @@ class AutofillAgent : public content::RenderFrameObserver,
|
|||
bool OnMessageReceived(const IPC::Message& message) override;
|
||||
|
||||
// blink::WebAutofillClient:
|
||||
void textFieldDidEndEditing(const blink::WebInputElement&) override;
|
||||
void textFieldDidChange(const blink::WebFormControlElement&) override;
|
||||
void textFieldDidChangeImpl(const blink::WebFormControlElement&);
|
||||
void textFieldDidReceiveKeyDown(const blink::WebInputElement&,
|
||||
void TextFieldDidEndEditing(const blink::WebInputElement&) override;
|
||||
void TextFieldDidChange(const blink::WebFormControlElement&) override;
|
||||
void TextFieldDidChangeImpl(const blink::WebFormControlElement&);
|
||||
void TextFieldDidReceiveKeyDown(const blink::WebInputElement&,
|
||||
const blink::WebKeyboardEvent&) override;
|
||||
void openTextDataListChooser(const blink::WebInputElement&) override;
|
||||
void dataListOptionsChanged(const blink::WebInputElement&) override;
|
||||
void OpenTextDataListChooser(const blink::WebInputElement&) override;
|
||||
void DataListOptionsChanged(const blink::WebInputElement&) override;
|
||||
|
||||
bool IsUserGesture() const;
|
||||
void HidePopup();
|
||||
|
|
|
|||
|
|
@ -51,17 +51,17 @@ void AtomRenderFrameObserver::CreateIsolatedWorldContext() {
|
|||
|
||||
// This maps to the name shown in the context combo box in the Console tab
|
||||
// of the dev tools.
|
||||
frame->setIsolatedWorldHumanReadableName(
|
||||
frame->SetIsolatedWorldHumanReadableName(
|
||||
World::ISOLATED_WORLD,
|
||||
blink::WebString::fromUTF8("Electron Isolated Context"));
|
||||
blink::WebString::FromUTF8("Electron Isolated Context"));
|
||||
|
||||
// Setup document's origin policy in isolated world
|
||||
frame->setIsolatedWorldSecurityOrigin(
|
||||
World::ISOLATED_WORLD, frame->document().getSecurityOrigin());
|
||||
frame->SetIsolatedWorldSecurityOrigin(
|
||||
World::ISOLATED_WORLD, frame->GetDocument().GetSecurityOrigin());
|
||||
|
||||
// Create initial script context in isolated world
|
||||
blink::WebScriptSource source("void 0");
|
||||
frame->executeScriptInIsolatedWorld(World::ISOLATED_WORLD, &source, 1);
|
||||
frame->ExecuteScriptInIsolatedWorld(World::ISOLATED_WORLD, &source, 1);
|
||||
}
|
||||
|
||||
bool AtomRenderFrameObserver::IsMainWorld(int world_id) {
|
||||
|
|
|
|||
|
|
@ -87,10 +87,10 @@ AtomRenderViewObserver::~AtomRenderViewObserver() {
|
|||
void AtomRenderViewObserver::EmitIPCEvent(blink::WebFrame* frame,
|
||||
const base::string16& channel,
|
||||
const base::ListValue& args) {
|
||||
if (!frame || frame->isWebRemoteFrame())
|
||||
if (!frame || frame->IsWebRemoteFrame())
|
||||
return;
|
||||
|
||||
v8::Isolate* isolate = blink::mainThreadIsolate();
|
||||
v8::Isolate* isolate = blink::MainThreadIsolate();
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
|
||||
v8::Local<v8::Context> context = renderer_client_->GetContext(frame, isolate);
|
||||
|
|
@ -120,7 +120,7 @@ void AtomRenderViewObserver::DidCreateDocumentElement(
|
|||
|
||||
void AtomRenderViewObserver::DraggableRegionsChanged(blink::WebFrame* frame) {
|
||||
blink::WebVector<blink::WebDraggableRegion> webregions =
|
||||
frame->document().draggableRegions();
|
||||
frame->GetDocument().DraggableRegions();
|
||||
std::vector<DraggableRegion> regions;
|
||||
for (auto& webregion : webregions) {
|
||||
DraggableRegion region;
|
||||
|
|
@ -156,22 +156,22 @@ void AtomRenderViewObserver::OnBrowserMessage(bool send_to_all,
|
|||
if (!render_view()->GetWebView())
|
||||
return;
|
||||
|
||||
blink::WebFrame* frame = render_view()->GetWebView()->mainFrame();
|
||||
if (!frame || frame->isWebRemoteFrame())
|
||||
blink::WebFrame* frame = render_view()->GetWebView()->MainFrame();
|
||||
if (!frame || frame->IsWebRemoteFrame())
|
||||
return;
|
||||
|
||||
EmitIPCEvent(frame, channel, args);
|
||||
|
||||
// Also send the message to all sub-frames.
|
||||
if (send_to_all) {
|
||||
for (blink::WebFrame* child = frame->firstChild(); child;
|
||||
child = child->nextSibling())
|
||||
for (blink::WebFrame* child = frame->FirstChild(); child;
|
||||
child = child->NextSibling())
|
||||
EmitIPCEvent(child, channel, args);
|
||||
}
|
||||
}
|
||||
|
||||
void AtomRenderViewObserver::OnOffscreen() {
|
||||
blink::WebView::setUseExternalPopupMenus(false);
|
||||
blink::WebView::SetUseExternalPopupMenus(false);
|
||||
}
|
||||
|
||||
} // namespace atom
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ namespace atom {
|
|||
namespace {
|
||||
|
||||
bool IsDevToolsExtension(content::RenderFrame* render_frame) {
|
||||
return static_cast<GURL>(render_frame->GetWebFrame()->document().url())
|
||||
return static_cast<GURL>(render_frame->GetWebFrame()->GetDocument().Url())
|
||||
.SchemeIs("chrome-extension");
|
||||
}
|
||||
|
||||
|
|
@ -174,9 +174,9 @@ void AtomRendererClient::WillDestroyWorkerContextOnWorkerThread(
|
|||
v8::Local<v8::Context> AtomRendererClient::GetContext(
|
||||
blink::WebFrame* frame, v8::Isolate* isolate) {
|
||||
if (isolated_world())
|
||||
return frame->worldScriptContext(isolate, World::ISOLATED_WORLD);
|
||||
return frame->WorldScriptContext(isolate, World::ISOLATED_WORLD);
|
||||
else
|
||||
return frame->mainWorldScriptContext();
|
||||
return frame->MainWorldScriptContext();
|
||||
}
|
||||
|
||||
void AtomRendererClient::SetupMainWorldOverrides(
|
||||
|
|
|
|||
|
|
@ -110,12 +110,12 @@ class AtomSandboxedRenderViewObserver : public AtomRenderViewObserver {
|
|||
void EmitIPCEvent(blink::WebFrame* frame,
|
||||
const base::string16& channel,
|
||||
const base::ListValue& args) override {
|
||||
if (!frame || frame->isWebRemoteFrame())
|
||||
if (!frame || frame->IsWebRemoteFrame())
|
||||
return;
|
||||
|
||||
auto isolate = blink::mainThreadIsolate();
|
||||
auto isolate = blink::MainThreadIsolate();
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
auto context = frame->mainWorldScriptContext();
|
||||
auto context = frame->MainWorldScriptContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> argv[] = {
|
||||
mate::ConvertToV8(isolate, channel),
|
||||
|
|
|
|||
|
|
@ -14,45 +14,45 @@ namespace atom {
|
|||
ContentSettingsObserver::ContentSettingsObserver(
|
||||
content::RenderFrame* render_frame)
|
||||
: content::RenderFrameObserver(render_frame) {
|
||||
render_frame->GetWebFrame()->setContentSettingsClient(this);
|
||||
render_frame->GetWebFrame()->SetContentSettingsClient(this);
|
||||
}
|
||||
|
||||
ContentSettingsObserver::~ContentSettingsObserver() {
|
||||
}
|
||||
|
||||
bool ContentSettingsObserver::allowDatabase(
|
||||
bool ContentSettingsObserver::AllowDatabase(
|
||||
const blink::WebString& name,
|
||||
const blink::WebString& display_name,
|
||||
unsigned estimated_size) {
|
||||
blink::WebFrame* frame = render_frame()->GetWebFrame();
|
||||
if (frame->getSecurityOrigin().isUnique() ||
|
||||
frame->top()->getSecurityOrigin().isUnique())
|
||||
if (frame->GetSecurityOrigin().IsUnique() ||
|
||||
frame->Top()->GetSecurityOrigin().IsUnique())
|
||||
return false;
|
||||
auto origin = blink::WebStringToGURL(frame->getSecurityOrigin().toString());
|
||||
auto origin = blink::WebStringToGURL(frame->GetSecurityOrigin().ToString());
|
||||
if (!origin.IsStandard())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ContentSettingsObserver::allowStorage(bool local) {
|
||||
bool ContentSettingsObserver::AllowStorage(bool local) {
|
||||
blink::WebFrame* frame = render_frame()->GetWebFrame();
|
||||
if (frame->getSecurityOrigin().isUnique() ||
|
||||
frame->top()->getSecurityOrigin().isUnique())
|
||||
if (frame->GetSecurityOrigin().IsUnique() ||
|
||||
frame->Top()->GetSecurityOrigin().IsUnique())
|
||||
return false;
|
||||
auto origin = blink::WebStringToGURL(frame->getSecurityOrigin().toString());
|
||||
auto origin = blink::WebStringToGURL(frame->GetSecurityOrigin().ToString());
|
||||
if (!origin.IsStandard())
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ContentSettingsObserver::allowIndexedDB(
|
||||
bool ContentSettingsObserver::AllowIndexedDB(
|
||||
const blink::WebString& name,
|
||||
const blink::WebSecurityOrigin& security_origin) {
|
||||
blink::WebFrame* frame = render_frame()->GetWebFrame();
|
||||
if (frame->getSecurityOrigin().isUnique() ||
|
||||
frame->top()->getSecurityOrigin().isUnique())
|
||||
if (frame->GetSecurityOrigin().IsUnique() ||
|
||||
frame->Top()->GetSecurityOrigin().IsUnique())
|
||||
return false;
|
||||
auto origin = blink::WebStringToGURL(frame->getSecurityOrigin().toString());
|
||||
auto origin = blink::WebStringToGURL(frame->GetSecurityOrigin().ToString());
|
||||
if (!origin.IsStandard())
|
||||
return false;
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -18,11 +18,11 @@ class ContentSettingsObserver : public content::RenderFrameObserver,
|
|||
~ContentSettingsObserver() override;
|
||||
|
||||
// blink::WebContentSettingsClient implementation.
|
||||
bool allowDatabase(const blink::WebString& name,
|
||||
bool AllowDatabase(const blink::WebString& name,
|
||||
const blink::WebString& display_name,
|
||||
unsigned estimated_size) override;
|
||||
bool allowStorage(bool local) override;
|
||||
bool allowIndexedDB(const blink::WebString& name,
|
||||
bool AllowStorage(bool local) override;
|
||||
bool AllowIndexedDB(const blink::WebString& name,
|
||||
const blink::WebSecurityOrigin& security_origin) override;
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -84,15 +84,15 @@ void RendererClientBase::AddRenderBindings(
|
|||
}
|
||||
|
||||
void RendererClientBase::RenderThreadStarted() {
|
||||
blink::WebCustomElement::addEmbedderCustomElementName("webview");
|
||||
blink::WebCustomElement::addEmbedderCustomElementName("browserplugin");
|
||||
blink::WebCustomElement::AddEmbedderCustomElementName("webview");
|
||||
blink::WebCustomElement::AddEmbedderCustomElementName("browserplugin");
|
||||
|
||||
// Parse --secure-schemes=scheme1,scheme2
|
||||
std::vector<std::string> secure_schemes_list =
|
||||
ParseSchemesCLISwitch(switches::kSecureSchemes);
|
||||
for (const std::string& scheme : secure_schemes_list)
|
||||
blink::SchemeRegistry::registerURLSchemeAsSecure(
|
||||
WTF::String::fromUTF8(scheme.data(), scheme.length()));
|
||||
blink::SchemeRegistry::RegisterURLSchemeAsSecure(
|
||||
WTF::String::FromUTF8(scheme.data(), scheme.length()));
|
||||
|
||||
preferences_manager_.reset(new PreferencesManager);
|
||||
|
||||
|
|
@ -128,13 +128,13 @@ void RendererClientBase::RenderFrameCreated(
|
|||
|
||||
// Allow file scheme to handle service worker by default.
|
||||
// FIXME(zcbenz): Can this be moved elsewhere?
|
||||
blink::WebSecurityPolicy::registerURLSchemeAsAllowingServiceWorkers("file");
|
||||
blink::WebSecurityPolicy::RegisterURLSchemeAsAllowingServiceWorkers("file");
|
||||
|
||||
// This is required for widevine plugin detection provided during runtime.
|
||||
blink::resetPluginCache();
|
||||
blink::ResetPluginCache();
|
||||
|
||||
// Allow access to file scheme from pdf viewer.
|
||||
blink::WebSecurityPolicy::addOriginAccessWhitelistEntry(
|
||||
blink::WebSecurityPolicy::AddOriginAccessWhitelistEntry(
|
||||
GURL(kPdfViewerUIOrigin), "file", "", true);
|
||||
}
|
||||
|
||||
|
|
@ -145,20 +145,20 @@ void RendererClientBase::RenderViewCreated(content::RenderView* render_view) {
|
|||
|
||||
base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
|
||||
if (cmd->HasSwitch(switches::kGuestInstanceID)) { // webview.
|
||||
web_frame_widget->setBaseBackgroundColor(SK_ColorTRANSPARENT);
|
||||
web_frame_widget->SetBaseBackgroundColor(SK_ColorTRANSPARENT);
|
||||
} else { // normal window.
|
||||
// If backgroundColor is specified then use it.
|
||||
std::string name = cmd->GetSwitchValueASCII(switches::kBackgroundColor);
|
||||
// Otherwise use white background.
|
||||
SkColor color = name.empty() ? SK_ColorWHITE : ParseHexColor(name);
|
||||
web_frame_widget->setBaseBackgroundColor(color);
|
||||
web_frame_widget->SetBaseBackgroundColor(color);
|
||||
}
|
||||
}
|
||||
|
||||
void RendererClientBase::DidClearWindowObject(
|
||||
content::RenderFrame* render_frame) {
|
||||
// Make sure every page will get a script context created.
|
||||
render_frame->GetWebFrame()->executeScript(blink::WebScriptSource("void 0"));
|
||||
render_frame->GetWebFrame()->ExecuteScript(blink::WebScriptSource("void 0"));
|
||||
}
|
||||
|
||||
blink::WebSpeechSynthesizer* RendererClientBase::OverrideSpeechSynthesizer(
|
||||
|
|
@ -172,8 +172,8 @@ bool RendererClientBase::OverrideCreatePlugin(
|
|||
const blink::WebPluginParams& params,
|
||||
blink::WebPlugin** plugin) {
|
||||
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
|
||||
if (params.mimeType.utf8() == content::kBrowserPluginMimeType ||
|
||||
params.mimeType.utf8() == kPdfPluginMimeType ||
|
||||
if (params.mime_type.Utf8() == content::kBrowserPluginMimeType ||
|
||||
params.mime_type.Utf8() == kPdfPluginMimeType ||
|
||||
command_line->HasSwitch(switches::kEnablePlugins))
|
||||
return false;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue