The Blink Rename

atom/browser/api/atom_api_web_contents.cc

@@ -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());

atom/browser/common_web_contents_delegate_mac.mm

@@ -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_) {

atom/browser/native_window_mac.mm

@@ -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:

atom/browser/osr/osr_render_widget_host_view.cc

@@ -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)

atom/browser/osr/osr_render_widget_host_view.h

@@ -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();

atom/browser/ui/webui/pdf_viewer_ui.cc

@@ -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);

atom/common/api/remote_object_freer.cc

@@ -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.
 

atom/common/keyboard_util.cc

@@ -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;

atom/common/mouse_util.cc

@@ -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";
   }
 }

atom/common/native_mate_converters/blink_converter.cc

@@ -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();

atom/common/native_mate_converters/content_converter.cc

@@ -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);

atom/renderer/api/atom_api_renderer_ipc.cc

@@ -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.
 

atom/renderer/api/atom_api_spell_check_client.cc

@@ -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) {
 }
 

atom/renderer/api/atom_api_spell_check_client.h

@@ -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.

atom/renderer/api/atom_api_web_frame.cc

@@ -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);
 }

atom/renderer/atom_autofill_agent.cc

@@ -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);
   }

atom/renderer/atom_autofill_agent.h

@@ -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();

atom/renderer/atom_render_frame_observer.cc

@@ -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) {

atom/renderer/atom_render_view_observer.cc

@@ -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

atom/renderer/atom_renderer_client.cc

@@ -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(

atom/renderer/atom_sandboxed_renderer_client.cc

@@ -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),

atom/renderer/content_settings_observer.cc

@@ -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;

atom/renderer/content_settings_observer.h

@@ -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:

atom/renderer/renderer_client_base.cc

@@ -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;
 

chromium_src/chrome/browser/ssl/security_state_tab_helper.cc

@@ -107,7 +107,8 @@ void SecurityStateTabHelper::VisibleSecurityStateChanged() {
 void SecurityStateTabHelper::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (time_of_http_warning_on_current_navigation_.is_null() ||
-      !navigation_handle->IsInMainFrame() || navigation_handle->IsSamePage()) {
+      !navigation_handle->IsInMainFrame() ||
+      navigation_handle->IsSameDocument()) {
     return;
   }
   // Record how quickly a user leaves a site after encountering an
@@ -126,7 +127,8 @@ void SecurityStateTabHelper::DidStartNavigation(
 
 void SecurityStateTabHelper::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
-  if (navigation_handle->IsInMainFrame() && !navigation_handle->IsSamePage()) {
+  if (navigation_handle->IsInMainFrame() &&
+     !navigation_handle->IsSameDocument()) {
     // Only reset the console message flag for main-frame navigations,
     // and not for same-page navigations like reference fragments and pushState.
     logged_http_warning_on_current_navigation_ = false;

chromium_src/chrome/common/print_messages.cc

@@ -22,7 +22,7 @@ PrintMsg_Print_Params::PrintMsg_Print_Params()
       preview_ui_id(-1),
       preview_request_id(0),
       is_first_request(false),
-      print_scaling_option(blink::WebPrintScalingOptionSourceSize),
+      print_scaling_option(blink::kWebPrintScalingOptionSourceSize),
       print_to_pdf(false),
       display_header_footer(false),
       title(),
@@ -48,7 +48,7 @@ void PrintMsg_Print_Params::Reset() {
   preview_ui_id = -1;
   preview_request_id = 0;
   is_first_request = false;
-  print_scaling_option = blink::WebPrintScalingOptionSourceSize;
+  print_scaling_option = blink::kWebPrintScalingOptionSourceSize;
   print_to_pdf = false;
   display_header_footer = false;
   title = base::string16();

chromium_src/chrome/common/print_messages.h

@@ -79,7 +79,7 @@ IPC_ENUM_TRAITS_MIN_MAX_VALUE(printing::DuplexMode,
                               printing::UNKNOWN_DUPLEX_MODE,
                               printing::SHORT_EDGE)
 IPC_ENUM_TRAITS_MAX_VALUE(blink::WebPrintScalingOption,
-                          blink::WebPrintScalingOptionLast)
+                          blink::kWebPrintScalingOptionLast)
 
 // Parameters for a render request.
 IPC_STRUCT_TRAITS_BEGIN(PrintMsg_Print_Params)

chromium_src/chrome/renderer/printing/print_web_view_helper.cc

@@ -96,7 +96,7 @@ PrintMsg_Print_Params GetCssPrintParams(
       dpi, kPixelsPerInch);
 
   if (frame) {
-    frame->pageSizeAndMarginsInPixels(page_index,
+    frame->PageSizeAndMarginsInPixels(page_index,
                                       page_size_in_pixels,
                                       margin_top_in_pixels,
                                       margin_right_in_pixels,
@@ -104,9 +104,9 @@ PrintMsg_Print_Params GetCssPrintParams(
                                       margin_left_in_pixels);
   }
 
-  double new_content_width = page_size_in_pixels.width() -
+  double new_content_width = page_size_in_pixels.Width() -
                           margin_left_in_pixels - margin_right_in_pixels;
-  double new_content_height = page_size_in_pixels.height() -
+  double new_content_height = page_size_in_pixels.Height() -
                            margin_top_in_pixels - margin_bottom_in_pixels;
 
   // Invalid page size and/or margins. We just use the default setting.
@@ -117,8 +117,8 @@ PrintMsg_Print_Params GetCssPrintParams(
   }
 
   page_css_params.page_size =
-      gfx::Size(ConvertUnit(page_size_in_pixels.width(), kPixelsPerInch, dpi),
-                ConvertUnit(page_size_in_pixels.height(), kPixelsPerInch, dpi));
+      gfx::Size(ConvertUnit(page_size_in_pixels.Width(), kPixelsPerInch, dpi),
+                ConvertUnit(page_size_in_pixels.Height(), kPixelsPerInch, dpi));
   page_css_params.content_size =
       gfx::Size(ConvertUnit(new_content_width, kPixelsPerInch, dpi),
               ConvertUnit(new_content_height, kPixelsPerInch, dpi));
@@ -214,53 +214,53 @@ void ComputeWebKitPrintParamsInDesiredDpi(
     const PrintMsg_Print_Params& print_params,
     blink::WebPrintParams* webkit_print_params) {
   int dpi = GetDPI(&print_params);
-  webkit_print_params->printerDPI = dpi;
-  webkit_print_params->printScalingOption = print_params.print_scaling_option;
+  webkit_print_params->printer_dpi = dpi;
+  webkit_print_params->print_scaling_option = print_params.print_scaling_option;
 
-  webkit_print_params->printContentArea.width =
+  webkit_print_params->print_content_area.width =
       ConvertUnit(print_params.content_size.width(), dpi,
                   print_params.desired_dpi);
-  webkit_print_params->printContentArea.height =
+  webkit_print_params->print_content_area.height =
       ConvertUnit(print_params.content_size.height(), dpi,
                   print_params.desired_dpi);
 
-  webkit_print_params->printableArea.x =
+  webkit_print_params->printable_area.x =
       ConvertUnit(print_params.printable_area.x(), dpi,
                   print_params.desired_dpi);
-  webkit_print_params->printableArea.y =
+  webkit_print_params->printable_area.y =
       ConvertUnit(print_params.printable_area.y(), dpi,
                   print_params.desired_dpi);
-  webkit_print_params->printableArea.width =
+  webkit_print_params->printable_area.width =
       ConvertUnit(print_params.printable_area.width(), dpi,
                   print_params.desired_dpi);
-  webkit_print_params->printableArea.height =
+  webkit_print_params->printable_area.height =
       ConvertUnit(print_params.printable_area.height(),
                   dpi, print_params.desired_dpi);
 
-  webkit_print_params->paperSize.width =
+  webkit_print_params->paper_size.width =
       ConvertUnit(print_params.page_size.width(), dpi,
                   print_params.desired_dpi);
-  webkit_print_params->paperSize.height =
+  webkit_print_params->paper_size.height =
       ConvertUnit(print_params.page_size.height(), dpi,
                   print_params.desired_dpi);
 }
 
 blink::WebPlugin* GetPlugin(const blink::WebFrame* frame) {
-  return frame->document().isPluginDocument() ?
-         frame->document().to<blink::WebPluginDocument>().plugin() : NULL;
+  return frame->GetDocument().IsPluginDocument() ?
+         frame->GetDocument().To<blink::WebPluginDocument>().Plugin() : NULL;
 }
 
 bool PrintingNodeOrPdfFrame(const blink::WebFrame* frame,
                             const blink::WebNode& node) {
-  if (!node.isNull())
+  if (!node.IsNull())
     return true;
   blink::WebPlugin* plugin = GetPlugin(frame);
-  return plugin && plugin->supportsPaginatedPrint();
+  return plugin && plugin->SupportsPaginatedPrint();
 }
 
 MarginType GetMarginsForPdf(blink::WebFrame* frame,
                             const blink::WebNode& node) {
-  if (frame->isPrintScalingDisabledForPlugin(node))
+  if (frame->IsPrintScalingDisabledForPlugin(node))
     return NO_MARGINS;
   else
     return PRINTABLE_AREA_MARGINS;
@@ -324,7 +324,7 @@ FrameReference::~FrameReference() {
 
 void FrameReference::Reset(blink::WebLocalFrame* frame) {
   if (frame) {
-    view_ = frame->view();
+    view_ = frame->View();
     frame_ = frame;
   } else {
     view_ = NULL;
@@ -335,8 +335,8 @@ void FrameReference::Reset(blink::WebLocalFrame* frame) {
 blink::WebLocalFrame* FrameReference::GetFrame() {
   if (view_ == NULL || frame_ == NULL)
     return NULL;
-  for (blink::WebFrame* frame = view_->mainFrame(); frame != NULL;
-       frame = frame->traverseNext()) {
+  for (blink::WebFrame* frame = view_->MainFrame(); frame != NULL;
+       frame = frame->TraverseNext()) {
     if (frame == frame_)
       return frame_;
   }
@@ -357,7 +357,7 @@ float PrintWebViewHelper::RenderPageContent(blink::WebFrame* frame,
   SkAutoCanvasRestore auto_restore(canvas, true);
   canvas->translate((content_area.x() - canvas_area.x()) / scale_factor,
                     (content_area.y() - canvas_area.y()) / scale_factor);
-  return frame->printPage(page_number, canvas);
+  return frame->PrintPage(page_number, canvas);
 }
 
 // Class that calls the Begin and End print functions on the frame and changes
@@ -395,16 +395,16 @@ class PrepareFrameAndViewForPrint : public blink::WebViewClient,
 
   bool IsLoadingSelection() {
     // It's not selection if not |owns_web_view_|.
-    return owns_web_view_ && frame() && frame()->isLoading();
+    return owns_web_view_ && frame() && frame()->IsLoading();
   }
 
  protected:
   // blink::WebViewClient override:
-  void didStopLoading() override;
-  bool allowsBrokenNullLayerTreeView() const override;
+  void DidStopLoading() override;
+  bool AllowsBrokenNullLayerTreeView() const override;
 
   // blink::WebFrameClient:
-  blink::WebLocalFrame* createChildFrame(
+  blink::WebLocalFrame* CreateChildFrame(
       blink::WebLocalFrame* parent,
       blink::WebTreeScopeType scope,
       const blink::WebString& name,
@@ -453,13 +453,13 @@ PrepareFrameAndViewForPrint::PrepareFrameAndViewForPrint(
       !PrintingNodeOrPdfFrame(frame, node_to_print_)) {
     bool fit_to_page = ignore_css_margins &&
                        print_params.print_scaling_option ==
-                            blink::WebPrintScalingOptionFitToPrintableArea;
+                            blink::kWebPrintScalingOptionFitToPrintableArea;
     ComputeWebKitPrintParamsInDesiredDpi(params, &web_print_params_);
-    frame->printBegin(web_print_params_, node_to_print_);
+    frame->PrintBegin(web_print_params_, node_to_print_);
     print_params = CalculatePrintParamsForCss(frame, 0, print_params,
                                               ignore_css_margins, fit_to_page,
                                               NULL);
-    frame->printEnd();
+    frame->PrintEnd();
   }
   ComputeWebKitPrintParamsInDesiredDpi(print_params, &web_print_params_);
 }
@@ -475,8 +475,8 @@ void PrepareFrameAndViewForPrint::ResizeForPrinting() {
   // minimum (default) scaling.
   // This is important for sites that try to fill the page.
   // The 1.25 value is |printingMinimumShrinkFactor|.
-  gfx::Size print_layout_size(web_print_params_.printContentArea.width,
-                              web_print_params_.printContentArea.height);
+  gfx::Size print_layout_size(web_print_params_.print_content_area.width,
+                              web_print_params_.print_content_area.height);
   print_layout_size.set_height(
       static_cast<int>(static_cast<double>(print_layout_size.height()) * 1.25));
 
@@ -485,22 +485,22 @@ void PrepareFrameAndViewForPrint::ResizeForPrinting() {
 
   // Backup size and offset if it's a local frame.
   blink::WebView* web_view = frame_.view();
-  if (blink::WebFrame* web_frame = web_view->mainFrame()) {
-    if (web_frame->isWebLocalFrame())
-      prev_scroll_offset_ = web_frame->getScrollOffset();
+  if (blink::WebFrame* web_frame = web_view->MainFrame()) {
+    if (web_frame->IsWebLocalFrame())
+      prev_scroll_offset_ = web_frame->GetScrollOffset();
   }
-  prev_view_size_ = web_view->size();
+  prev_view_size_ = web_view->Size();
 
-  web_view->resize(print_layout_size);
+  web_view->Resize(print_layout_size);
 }
 
 
 void PrepareFrameAndViewForPrint::StartPrinting() {
   ResizeForPrinting();
   blink::WebView* web_view = frame_.view();
-  web_view->settings()->setShouldPrintBackgrounds(should_print_backgrounds_);
+  web_view->GetSettings()->SetShouldPrintBackgrounds(should_print_backgrounds_);
   expected_pages_count_ =
-      frame()->printBegin(web_print_params_, node_to_print_);
+      frame()->PrintBegin(web_print_params_, node_to_print_);
   is_printing_started_ = true;
 }
 
@@ -521,7 +521,7 @@ void PrepareFrameAndViewForPrint::CopySelection(
   ResizeForPrinting();
   std::string url_str = "data:text/html;charset=utf-8,";
   url_str.append(
-      net::EscapeQueryParamValue(frame()->selectionAsMarkup().utf8(), false));
+      net::EscapeQueryParamValue(frame()->SelectionAsMarkup().Utf8(), false));
   RestoreSize();
   // Create a new WebView with the same settings as the current display one.
   // Except that we disable javascript (don't want any active content running
@@ -530,44 +530,44 @@ void PrepareFrameAndViewForPrint::CopySelection(
   prefs.javascript_enabled = false;
 
   blink::WebView* web_view =
-      blink::WebView::create(this, blink::WebPageVisibilityStateVisible);
+      blink::WebView::Create(this, blink::kWebPageVisibilityStateVisible);
   owns_web_view_ = true;
   content::RenderView::ApplyWebPreferences(prefs, web_view);
-  blink::WebLocalFrame* main_frame = blink::WebLocalFrame::create(
-      blink::WebTreeScopeType::Document, this, nullptr, nullptr);
-  web_view->setMainFrame(main_frame);
-  blink::WebFrameWidget::create(this, web_view, main_frame);
-  frame_.Reset(web_view->mainFrame()->toWebLocalFrame());
-  node_to_print_.reset();
-
-  // When loading is done this will call didStopLoading() and that will do the
+  blink::WebLocalFrame* main_frame = blink::WebLocalFrame::Create(
+      blink::WebTreeScopeType::kDocument, this, nullptr, nullptr);
+  web_view->SetMainFrame(main_frame);
+  blink::WebFrameWidget::Create(this, web_view, main_frame);
+  frame_.Reset(web_view->MainFrame()->ToWebLocalFrame());
+  node_to_print_.Reset();
+
+  // When loading is done this will call DidStopLoading() and that will do the
   // actual printing.
-  frame()->loadRequest(blink::WebURLRequest(GURL(url_str)));
+  frame()->LoadRequest(blink::WebURLRequest(GURL(url_str)));
 }
 
-bool PrepareFrameAndViewForPrint::allowsBrokenNullLayerTreeView() const {
+bool PrepareFrameAndViewForPrint::AllowsBrokenNullLayerTreeView() const {
   return true;
 }
 
-void PrepareFrameAndViewForPrint::didStopLoading() {
+void PrepareFrameAndViewForPrint::DidStopLoading() {
   DCHECK(!on_ready_.is_null());
   // Don't call callback here, because it can delete |this| and WebView that is
-  // called didStopLoading.
+  // called DidStopLoading.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrepareFrameAndViewForPrint::CallOnReady,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
-blink::WebLocalFrame* PrepareFrameAndViewForPrint::createChildFrame(
+blink::WebLocalFrame* PrepareFrameAndViewForPrint::CreateChildFrame(
     blink::WebLocalFrame* parent,
     blink::WebTreeScopeType scope,
     const blink::WebString& name,
     const blink::WebString& unique_name,
     blink::WebSandboxFlags sandbox_flags,
     const blink::WebFrameOwnerProperties& frame_owner_properties) {
-  blink::WebLocalFrame* frame = blink::WebLocalFrame::create(
+  blink::WebLocalFrame* frame = blink::WebLocalFrame::Create(
       scope, this, nullptr, nullptr);
-  parent->appendChild(frame);
+  parent->AppendChild(frame);
   return frame;
 }
 
@@ -579,30 +579,30 @@ void PrepareFrameAndViewForPrint::RestoreSize() {
   if (!frame())
     return;
 
-  blink::WebView* web_view = frame_.GetFrame()->view();
-  web_view->resize(prev_view_size_);
-  if (blink::WebFrame* web_frame = web_view->mainFrame()) {
-    if (web_frame->isWebLocalFrame())
-      web_frame->setScrollOffset(prev_scroll_offset_);
+  blink::WebView* web_view = frame_.GetFrame()->View();
+  web_view->Resize(prev_view_size_);
+  if (blink::WebFrame* web_frame = web_view->MainFrame()) {
+    if (web_frame->IsWebLocalFrame())
+      web_frame->SetScrollOffset(prev_scroll_offset_);
   }
 }
 
 void PrepareFrameAndViewForPrint::FinishPrinting() {
   blink::WebLocalFrame* frame = frame_.GetFrame();
   if (frame) {
-    blink::WebView* web_view = frame->view();
+    blink::WebView* web_view = frame->View();
     if (is_printing_started_) {
       is_printing_started_ = false;
-      frame->printEnd();
+      frame->PrintEnd();
       if (!owns_web_view_) {
-        web_view->settings()->setShouldPrintBackgrounds(false);
+        web_view->GetSettings()->SetShouldPrintBackgrounds(false);
         RestoreSize();
       }
     }
     if (owns_web_view_) {
-      DCHECK(!frame->isLoading());
+      DCHECK(!frame->IsLoading());
       owns_web_view_ = false;
-      web_view->close();
+      web_view->Close();
     }
   }
   frame_.Reset(NULL);
@@ -825,7 +825,7 @@ bool PrintWebViewHelper::FinalizePrintReadyDocument() {
 }
 
 void PrintWebViewHelper::PrintNode(const blink::WebNode& node) {
-  if (node.isNull() || !node.document().frame()) {
+  if (node.IsNull() || !node.GetDocument().GetFrame()) {
     // This can occur when the context menu refers to an invalid WebNode.
     // See http://crbug.com/100890#c17 for a repro case.
     return;
@@ -840,7 +840,7 @@ void PrintWebViewHelper::PrintNode(const blink::WebNode& node) {
 
   print_node_in_progress_ = true;
   blink::WebNode duplicate_node(node);
-  Print(duplicate_node.document().frame(), duplicate_node);
+  Print(duplicate_node.GetDocument().GetFrame(), duplicate_node);
 
   print_node_in_progress_ = false;
 }
@@ -988,7 +988,7 @@ void PrintWebViewHelper::ComputePageLayoutInPointsForCss(
   PrintMsg_Print_Params params = CalculatePrintParamsForCss(
       frame, page_index, page_params, ignore_css_margins,
       page_params.print_scaling_option ==
-          blink::WebPrintScalingOptionFitToPrintableArea,
+          blink::kWebPrintScalingOptionFitToPrintableArea,
       scale_factor);
   CalculatePageLayoutFromPrintParams(params, page_layout_in_points);
 }
@@ -1015,10 +1015,10 @@ bool PrintWebViewHelper::InitPrintSettings(bool fit_to_paper_size,
   settings.pages.clear();
 
   settings.params.print_scaling_option =
-      blink::WebPrintScalingOptionSourceSize;
+      blink::kWebPrintScalingOptionSourceSize;
   if (fit_to_paper_size) {
     settings.params.print_scaling_option =
-        blink::WebPrintScalingOptionFitToPrintableArea;
+        blink::kWebPrintScalingOptionFitToPrintableArea;
   }
 
   SetPrintPagesParams(settings);
@@ -1092,7 +1092,7 @@ bool PrintWebViewHelper::UpdatePrintSettings(
     settings.params.print_to_pdf = true;
     UpdateFrameMarginsCssInfo(*job_settings);
     settings.params.print_scaling_option =
-      blink::WebPrintScalingOptionSourceSize;
+      blink::kWebPrintScalingOptionSourceSize;
   }
 
   SetPrintPagesParams(settings);
@@ -1114,7 +1114,7 @@ bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebLocalFrame* frame,
   PrintMsg_PrintPages_Params print_settings;
 
   params.cookie = print_pages_params_->params.document_cookie;
-  params.has_selection = frame->hasSelection();
+  params.has_selection = frame->HasSelection();
   params.expected_pages_count = expected_pages_count;
   MarginType margin_type = DEFAULT_MARGINS;
   if (PrintingNodeOrPdfFrame(frame, node))
@@ -1225,16 +1225,16 @@ void PrintWebViewHelper::PrintPreviewContext::InitWithFrame(
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
   source_frame_.Reset(web_frame);
-  source_node_.reset();
+  source_node_.Reset();
 }
 
 void PrintWebViewHelper::PrintPreviewContext::InitWithNode(
     const blink::WebNode& web_node) {
-  DCHECK(!web_node.isNull());
-  DCHECK(web_node.document().frame());
+  DCHECK(!web_node.IsNull());
+  DCHECK(web_node.GetDocument().GetFrame());
   DCHECK(!IsRendering());
   state_ = INITIALIZED;
-  source_frame_.Reset(web_node.document().frame());
+  source_frame_.Reset(web_node.GetDocument().GetFrame());
   source_node_ = web_node;
 }
 
@@ -1367,7 +1367,7 @@ bool PrintWebViewHelper::PrintPreviewContext::IsModifiable() {
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::HasSelection() {
-  return IsModifiable() && source_frame()->hasSelection();
+  return IsModifiable() && source_frame()->HasSelection();
 }
 
 bool PrintWebViewHelper::PrintPreviewContext::IsLastPageOfPrintReadyMetafile()

chromium_src/chrome/renderer/printing/print_web_view_helper_mac.mm

@@ -94,7 +94,7 @@ void PrintWebViewHelper::RenderPage(const PrintMsg_Print_Params& params,
                                     gfx::Size* page_size,
                                     gfx::Rect* content_rect) {
   double scale_factor = 1.0f;
-  double webkit_shrink_factor = frame->getPrintPageShrink(page_number);
+  double webkit_shrink_factor = frame->GetPrintPageShrink(page_number);
   PageSizeMargins page_layout_in_points;
   gfx::Rect content_area;
 

chromium_src/chrome/renderer/tts_dispatcher.cc

@@ -52,35 +52,35 @@ bool TtsDispatcher::OnControlMessageReceived(const IPC::Message& message) {
   return false;
 }
 
-void TtsDispatcher::updateVoiceList() {
+void TtsDispatcher::UpdateVoiceList() {
   RenderThread::Get()->Send(new TtsHostMsg_InitializeVoiceList());
 }
 
-void TtsDispatcher::speak(const WebSpeechSynthesisUtterance& web_utterance) {
+void TtsDispatcher::Speak(const WebSpeechSynthesisUtterance& web_utterance) {
   int id = next_utterance_id_++;
 
   utterance_id_map_[id] = web_utterance;
 
   TtsUtteranceRequest utterance;
   utterance.id = id;
-  utterance.text = web_utterance.text().utf8();
-  utterance.lang = web_utterance.lang().utf8();
-  utterance.voice = web_utterance.voice().utf8();
-  utterance.volume = web_utterance.volume();
-  utterance.rate = web_utterance.rate();
-  utterance.pitch = web_utterance.pitch();
+  utterance.text = web_utterance.GetText().Utf8();
+  utterance.lang = web_utterance.Lang().Utf8();
+  utterance.voice = web_utterance.Voice().Utf8();
+  utterance.volume = web_utterance.Volume();
+  utterance.rate = web_utterance.Rate();
+  utterance.pitch = web_utterance.Pitch();
   RenderThread::Get()->Send(new TtsHostMsg_Speak(utterance));
 }
 
-void TtsDispatcher::pause() {
+void TtsDispatcher::Pause() {
   RenderThread::Get()->Send(new TtsHostMsg_Pause());
 }
 
-void TtsDispatcher::resume() {
+void TtsDispatcher::Resume() {
   RenderThread::Get()->Send(new TtsHostMsg_Resume());
 }
 
-void TtsDispatcher::cancel() {
+void TtsDispatcher::Cancel() {
   RenderThread::Get()->Send(new TtsHostMsg_Cancel());
 }
 
@@ -96,13 +96,13 @@ void TtsDispatcher::OnSetVoiceList(const std::vector<TtsVoice>& voices) {
   WebVector<WebSpeechSynthesisVoice> out_voices(voices.size());
   for (size_t i = 0; i < voices.size(); ++i) {
     out_voices[i] = WebSpeechSynthesisVoice();
-    out_voices[i].setVoiceURI(WebString::fromUTF8(voices[i].voice_uri));
-    out_voices[i].setName(WebString::fromUTF8(voices[i].name));
-    out_voices[i].setLanguage(WebString::fromUTF8(voices[i].lang));
-    out_voices[i].setIsLocalService(voices[i].local_service);
-    out_voices[i].setIsDefault(voices[i].is_default);
+    out_voices[i].SetVoiceURI(WebString::FromUTF8(voices[i].voice_uri));
+    out_voices[i].SetName(WebString::FromUTF8(voices[i].name));
+    out_voices[i].SetLanguage(WebString::FromUTF8(voices[i].lang));
+    out_voices[i].SetIsLocalService(voices[i].local_service);
+    out_voices[i].SetIsDefault(voices[i].is_default);
   }
-  synthesizer_client_->setVoiceList(out_voices);
+  synthesizer_client_->SetVoiceList(out_voices);
 }
 
 void TtsDispatcher::OnDidStartSpeaking(int utterance_id) {
@@ -110,45 +110,45 @@ void TtsDispatcher::OnDidStartSpeaking(int utterance_id) {
     return;
 
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
-  synthesizer_client_->didStartSpeaking(utterance);
+  synthesizer_client_->DidStartSpeaking(utterance);
 }
 
 void TtsDispatcher::OnDidFinishSpeaking(int utterance_id) {
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
-  synthesizer_client_->didFinishSpeaking(utterance);
+  synthesizer_client_->DidFinishSpeaking(utterance);
   utterance_id_map_.erase(utterance_id);
 }
 
 void TtsDispatcher::OnDidPauseSpeaking(int utterance_id) {
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
-  synthesizer_client_->didPauseSpeaking(utterance);
+  synthesizer_client_->DidPauseSpeaking(utterance);
 }
 
 void TtsDispatcher::OnDidResumeSpeaking(int utterance_id) {
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
-  synthesizer_client_->didResumeSpeaking(utterance);
+  synthesizer_client_->DidResumeSpeaking(utterance);
 }
 
 void TtsDispatcher::OnWordBoundary(int utterance_id, int char_index) {
   CHECK(char_index >= 0);
 
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
-  synthesizer_client_->wordBoundaryEventOccurred(
+  synthesizer_client_->WordBoundaryEventOccurred(
       utterance, static_cast<unsigned>(char_index));
 }
 
@@ -156,10 +156,10 @@ void TtsDispatcher::OnSentenceBoundary(int utterance_id, int char_index) {
   CHECK(char_index >= 0);
 
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
-  synthesizer_client_->sentenceBoundaryEventOccurred(
+  synthesizer_client_->SentenceBoundaryEventOccurred(
       utterance, static_cast<unsigned>(char_index));
 }
 
@@ -169,31 +169,31 @@ void TtsDispatcher::OnMarkerEvent(int utterance_id, int char_index) {
 
 void TtsDispatcher::OnWasInterrupted(int utterance_id) {
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
   // The web speech API doesn't support "interrupted".
-  synthesizer_client_->didFinishSpeaking(utterance);
+  synthesizer_client_->DidFinishSpeaking(utterance);
   utterance_id_map_.erase(utterance_id);
 }
 
 void TtsDispatcher::OnWasCancelled(int utterance_id) {
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
   // The web speech API doesn't support "cancelled".
-  synthesizer_client_->didFinishSpeaking(utterance);
+  synthesizer_client_->DidFinishSpeaking(utterance);
   utterance_id_map_.erase(utterance_id);
 }
 
 void TtsDispatcher::OnSpeakingErrorOccurred(int utterance_id,
                                             const std::string& error_message) {
   WebSpeechSynthesisUtterance utterance = FindUtterance(utterance_id);
-  if (utterance.isNull())
+  if (utterance.IsNull())
     return;
 
   // The web speech API doesn't support an error message.
-  synthesizer_client_->speakingErrorOccurred(utterance);
+  synthesizer_client_->SpeakingErrorOccurred(utterance);
   utterance_id_map_.erase(utterance_id);
 }

chromium_src/chrome/renderer/tts_dispatcher.h

@@ -38,12 +38,12 @@ class TtsDispatcher
   virtual bool OnControlMessageReceived(const IPC::Message& message) override;
 
   // blink::WebSpeechSynthesizer implementation.
-  virtual void updateVoiceList() override;
-  virtual void speak(const blink::WebSpeechSynthesisUtterance& utterance)
+  virtual void UpdateVoiceList() override;
+  virtual void Speak(const blink::WebSpeechSynthesisUtterance& utterance)
       override;
-  virtual void pause() override;
-  virtual void resume() override;
-  virtual void cancel() override;
+  virtual void Pause() override;
+  virtual void Resume() override;
+  virtual void Cancel() override;
 
   blink::WebSpeechSynthesisUtterance FindUtterance(int utterance_id);
 

chromium_src/components/pdf/renderer/pepper_pdf_host.cc

@@ -75,7 +75,7 @@ int32_t PepperPDFHost::OnHostMsgSaveAs(
   GURL url = instance->GetPluginURL();
   content::Referrer referrer;
   referrer.url = url;
-  referrer.policy = blink::WebReferrerPolicyDefault;
+  referrer.policy = blink::kWebReferrerPolicyDefault;
   referrer = content::Referrer::SanitizeForRequest(url, referrer);
   render_frame->Send(
       new PDFHostMsg_PDFSaveURLAs(render_frame->GetRoutingID(), url, referrer));