Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/render_widget_host_view_mac.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/render_widget_host_view_mac.h"
 
 #import <objc/runtime.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/basictypes.h"
@@ skipping 58 matching lines @@
 using content::BackingStoreMac;
 using content::BrowserAccessibility;
 using content::BrowserAccessibilityManager;
 using content::EditCommand;
 using content::NativeWebKeyboardEvent;
 using content::RenderViewHostImpl;
 using content::RenderWidgetHostImpl;
 using content::RenderWidgetHostViewMac;
 using content::RenderWidgetHostViewMacEditCommandHelper;
 using content::TextInputClientMac;
-using WebKit::WebInputEvent;
-using WebKit::WebInputEventFactory;
-using WebKit::WebMouseEvent;
-using WebKit::WebMouseWheelEvent;
+using blink::WebInputEvent;
+using blink::WebInputEventFactory;
+using blink::WebMouseEvent;
+using blink::WebMouseWheelEvent;
 
 enum CoreAnimationStatus {
   CORE_ANIMATION_DISABLED,
   CORE_ANIMATION_ENABLED_LAZY,
   CORE_ANIMATION_ENABLED_ALWAYS,
 };
 
 static CoreAnimationStatus GetCoreAnimationStatus() {
   // TODO(sail) Remove this.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 187 matching lines @@
 }
 
 @end
 
 namespace {
 
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
 // TODO(suzhe): Upstream this function.
-WebKit::WebColor WebColorFromNSColor(NSColor *color) {
+blink::WebColor WebColorFromNSColor(NSColor *color) {
   CGFloat r, g, b, a;
   [color getRed:&r green:&g blue:&b alpha:&a];
 
   return
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * a)), 255)) << 24 |
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * r)), 255)) << 16 |
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * g)), 255)) << 8  |
       std::max(0, std::min(static_cast<int>(lroundf(255.0f * b)), 255));
 }
 
 // Extract underline information from an attributed string. Mostly copied from
 // third_party/WebKit/Source/WebKit/mac/WebView/WebHTMLView.mm
 void ExtractUnderlines(
     NSAttributedString* string,
-    std::vector<WebKit::WebCompositionUnderline>* underlines) {
+    std::vector<blink::WebCompositionUnderline>* underlines) {
   int length = [[string string] length];
   int i = 0;
   while (i < length) {
     NSRange range;
     NSDictionary* attrs = [string attributesAtIndex:i
                               longestEffectiveRange:&range
                                             inRange:NSMakeRange(i, length - i)];
     if (NSNumber *style = [attrs objectForKey:NSUnderlineStyleAttributeName]) {
-      WebKit::WebColor color = SK_ColorBLACK;
+      blink::WebColor color = SK_ColorBLACK;
       if (NSColor *colorAttr =
           [attrs objectForKey:NSUnderlineColorAttributeName]) {
         color = WebColorFromNSColor(
             [colorAttr colorUsingColorSpaceName:NSDeviceRGBColorSpace]);
       }
-      underlines->push_back(WebKit::WebCompositionUnderline(
+      underlines->push_back(blink::WebCompositionUnderline(
           range.location, NSMaxRange(range), color, [style intValue] > 1));
     }
     i = range.location + range.length;
   }
 }
 
 // EnablePasswordInput() and DisablePasswordInput() are copied from
 // enableSecureTextInput() and disableSecureTextInput() functions in
 // third_party/WebKit/WebCore/platform/SecureTextInput.cpp
 // But we don't call EnableSecureEventInput() and DisableSecureEventInput()
@@ skipping 36 matching lines @@
   // case from extension popup windows.
   NSWindow* ancestor_window = [enclosing_window parentWindow];
   if (ancestor_window && (NSWidth([enclosing_window frame]) ==
                           NSWidth([ancestor_window frame]))) {
     enclosing_window = ancestor_window;
   }
 
   return enclosing_window;
 }
 
-WebKit::WebScreenInfo GetWebScreenInfo(NSView* view) {
+blink::WebScreenInfo GetWebScreenInfo(NSView* view) {
   gfx::Display display =
       gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(view);
 
   NSScreen* screen = [NSScreen deepestScreen];
 
-  WebKit::WebScreenInfo results;
+  blink::WebScreenInfo results;
 
   results.deviceScaleFactor = static_cast<int>(display.device_scale_factor());
   results.depth = NSBitsPerPixelFromDepth([screen depth]);
   results.depthPerComponent = NSBitsPerSampleFromDepth([screen depth]);
   results.isMonochrome =
       [[screen colorSpace] colorSpaceModel] == NSGrayColorSpaceModel;
   results.rect = display.bounds();
   results.availableRect = display.work_area();
   return results;
 }
 
 }  // namespace
 
 namespace content {
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewMac(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
-    WebKit::WebScreenInfo* results) {
+    blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewMac, public:
 
 RenderWidgetHostViewMac::RenderWidgetHostViewMac(RenderWidgetHost* widget)
     : render_widget_host_(RenderWidgetHostImpl::From(widget)),
       about_to_validate_and_paint_(false),
       call_set_needs_display_in_rect_pending_(false),
@@ skipping 198 matching lines @@
   return handled;
 }
 
 void RenderWidgetHostViewMac::InitAsChild(
     gfx::NativeView parent_view) {
 }
 
 void RenderWidgetHostViewMac::InitAsPopup(
     RenderWidgetHostView* parent_host_view,
     const gfx::Rect& pos) {
-  bool activatable = popup_type_ == WebKit::WebPopupTypeNone;
+  bool activatable = popup_type_ == blink::WebPopupTypeNone;
   [cocoa_view_ setCloseOnDeactivate:YES];
   [cocoa_view_ setCanBeKeyView:activatable ? YES : NO];
 
   NSPoint origin_global = NSPointFromCGPoint(pos.origin().ToCGPoint());
   if ([[NSScreen screens] count] > 0) {
     origin_global.y = [[[NSScreen screens] objectAtIndex:0] frame].size.height -
         pos.height() - origin_global.y;
   }
 
   popup_window_.reset([[RenderWidgetPopupWindow alloc]
@@ skipping 492 matching lines @@
                                     clickCount:0
                                       pressure:0];
   WebMouseEvent web_event =
       WebInputEventFactory::mouseEvent(event, cocoa_view_);
   if (showing)
     web_event.type = WebInputEvent::MouseLeave;
   ForwardMouseEvent(web_event);
 }
 
 bool RenderWidgetHostViewMac::IsPopup() const {
-  return popup_type_ != WebKit::WebPopupTypeNone;
+  return popup_type_ != blink::WebPopupTypeNone;
 }
 
 BackingStore* RenderWidgetHostViewMac::AllocBackingStore(
     const gfx::Size& size) {
   float scale = ScaleFactor(cocoa_view_);
   return new BackingStoreMac(render_widget_host_, size, scale);
 }
 
 void RenderWidgetHostViewMac::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
@@ skipping 543 matching lines @@
   }
   software_frame_manager_->SwapToNewFrameComplete(
       !render_widget_host_->is_hidden());
 
   [cocoa_view_ setNeedsDisplay:YES];
 }
 
 void RenderWidgetHostViewMac::OnAcceleratedCompositingStateChange() {
 }
 
-void RenderWidgetHostViewMac::GetScreenInfo(WebKit::WebScreenInfo* results) {
+void RenderWidgetHostViewMac::GetScreenInfo(blink::WebScreenInfo* results) {
   *results = GetWebScreenInfo(GetNativeView());
 }
 
 gfx::Rect RenderWidgetHostViewMac::GetBoundsInRootWindow() {
   // TODO(shess): In case of !window, the view has been removed from
   // the view hierarchy because the tab isn't main.  Could retrieve
   // the information from the main tab for our window.
   NSWindow* enclosing_window = ApparentWindowForView(cocoa_view_);
   if (!enclosing_window)
     return gfx::Rect();
@@ skipping 42 matching lines @@
 
   // Unlock position of mouse cursor and unhide it.
   CGAssociateMouseAndMouseCursorPosition(YES);
   [NSCursor unhide];
 
   if (render_widget_host_)
     render_widget_host_->LostMouseLock();
 }
 
 void RenderWidgetHostViewMac::UnhandledWheelEvent(
-    const WebKit::WebMouseWheelEvent& event) {
+    const blink::WebMouseWheelEvent& event) {
   // Only record a wheel event as unhandled if JavaScript handlers got a chance
   // to see it (no-op wheel events are ignored by the event dispatcher)
   if (event.deltaX || event.deltaY)
     [cocoa_view_ gotUnhandledWheelEvent];
 }
 
 bool RenderWidgetHostViewMac::Send(IPC::Message* message) {
   if (render_widget_host_)
     return render_widget_host_->Send(message);
   delete message;
@@ skipping 626 matching lines @@
   // edit commands, then we need to send the real key event and corresponding
   // edit commands here. This usually occurs when the input method wants to
   // finish current composition session but still wants the application to
   // handle the key event. See http://crbug.com/48161 for reference.
   if (delayEventUntilAfterImeCompostion) {
     // If |delayEventUntilAfterImeCompostion| is YES, then a fake key down event
     // with windowsKeyCode == 0xE5 has already been sent to webkit.
     // So before sending the real key down event, we need to send a fake key up
     // event to balance it.
     NativeWebKeyboardEvent fakeEvent = event;
-    fakeEvent.type = WebKit::WebInputEvent::KeyUp;
+    fakeEvent.type = blink::WebInputEvent::KeyUp;
     fakeEvent.skip_in_browser = true;
     widgetHost->ForwardKeyboardEvent(fakeEvent);
     // Not checking |renderWidgetHostView_->render_widget_host_| here because
     // a key event with |skip_in_browser| == true won't be handled by browser,
     // thus it won't destroy the widget.
 
     if (!editCommands_.empty()) {
       widgetHost->Send(new InputMsg_SetEditCommandsForNextKeyEvent(
           widgetHost->GetRoutingID(), editCommands_));
     }
     widgetHost->ForwardKeyboardEvent(event);
 
     // Calling ForwardKeyboardEvent() could have destroyed the widget. When the
     // widget was destroyed, |renderWidgetHostView_->render_widget_host_| will
     // be set to NULL. So we check it here and return immediately if it's NULL.
     if (!renderWidgetHostView_->render_widget_host_)
       return;
   }
 
   const NSUInteger kCtrlCmdKeyMask = NSControlKeyMask | NSCommandKeyMask;
   // Only send a corresponding key press event if there is no marked text.
   if (!hasMarkedText_) {
     if (!textInserted && textToBeInserted_.length() == 1) {
       // If a single character was inserted, then we just send it as a keypress
       // event.
-      event.type = WebKit::WebInputEvent::Char;
+      event.type = blink::WebInputEvent::Char;
       event.text[0] = textToBeInserted_[0];
       event.text[1] = 0;
       event.skip_in_browser = true;
       widgetHost->ForwardKeyboardEvent(event);
     } else if ((!textInserted || delayEventUntilAfterImeCompostion) &&
                [[theEvent characters] length] > 0 &&
                (([theEvent modifierFlags] & kCtrlCmdKeyMask) ||
                 (hasEditCommands_ && editCommands_.empty()))) {
       // We don't get insertText: calls if ctrl or cmd is down, or the key event
       // generates an insert command. So synthesize a keypress event for these
       // cases, unless the key event generated any other command.
-      event.type = WebKit::WebInputEvent::Char;
+      event.type = blink::WebInputEvent::Char;
       event.skip_in_browser = true;
       widgetHost->ForwardKeyboardEvent(event);
     }
   }
 
   // Possibly autohide the cursor.
   if ([RenderWidgetHostViewCocoa shouldAutohideCursorForEvent:theEvent])
     [NSCursor setHiddenUntilMouseMoves:YES];
 }
 
@@ skipping 1066 matching lines @@
   selectedRange_ = newSelRange;
   markedText_ = base::SysNSStringToUTF16(im_text);
   hasMarkedText_ = (length > 0);
 
   underlines_.clear();
   if (isAttributedString) {
     ExtractUnderlines(string, &underlines_);
   } else {
     // Use a thin black underline by default.
     underlines_.push_back(
-        WebKit::WebCompositionUnderline(0, length, SK_ColorBLACK, false));
+        blink::WebCompositionUnderline(0, length, SK_ColorBLACK, false));
   }
 
   // If we are handling a key down event, then SetComposition() will be
   // called in keyEvent: method.
   // Input methods of Mac use setMarkedText calls with an empty text to cancel
   // an ongoing composition. So, we should check whether or not the given text
   // is empty to update the input method state. (Our input method backend can
   // automatically cancels an ongoing composition when we send an empty text.
   // So, it is OK to send an empty text to the renderer.)
   if (!handlingKeyDown_) {
@@ skipping 377 matching lines @@
   return YES;
 }
 
 - (BOOL)isOpaque {
   if (renderWidgetHostView_->use_core_animation_)
     return YES;
   return [super isOpaque];
 }
 
 @end