Rename OS(DARWIN) to OS(MACOSX).

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 535 matching lines @@
     }
 
     if (m_pagePopup && pagePopup && m_pagePopup->hasSamePopupClient(pagePopup.get())) {
         // That click triggered a page popup that is the same as the one we just closed.
         // It needs to be closed.
         closePagePopup(m_pagePopup.get());
     }
 
     // Dispatch the contextmenu event regardless of if the click was swallowed.
     // On Windows, we handle it on mouse up, not down.
-#if OS(DARWIN)
+#if OS(MACOSX)
     if (event.button == WebMouseEvent::ButtonRight
         || (event.button == WebMouseEvent::ButtonLeft
             && event.modifiers & WebMouseEvent::ControlKey))
         mouseContextMenu(event);
 #elif OS(UNIX)
     if (event.button == WebMouseEvent::ButtonRight)
         mouseContextMenu(event);
 #endif
 }
 
@@ skipping 359 matching lines @@
         return true;
 
     RefPtr<Frame> frame = focusedWebCoreFrame();
     if (!frame)
         return false;
 
     EventHandler* handler = frame->eventHandler();
     if (!handler)
         return keyEventDefault(event);
 
-#if !OS(DARWIN)
+#if !OS(MACOSX)
     const WebInputEvent::Type contextMenuTriggeringEventType =
 #if OS(WINDOWS)
         WebInputEvent::KeyUp;
 #elif OS(UNIX)
         WebInputEvent::RawKeyDown;
 #endif
 
     bool isUnmodifiedMenuKey = !(event.modifiers & WebInputEvent::InputModifiers) && event.windowsKeyCode == VKEY_APPS;
     bool isShiftF10 = event.modifiers == WebInputEvent::ShiftKey && event.windowsKeyCode == VKEY_F10;
     if ((isUnmodifiedMenuKey || isShiftF10) && event.type == contextMenuTriggeringEventType) {
         sendContextMenuEvent(event);
         return true;
     }
-#endif // !OS(DARWIN)
+#endif // !OS(MACOSX)
 
     PlatformKeyboardEventBuilder evt(event);
 
     if (handler->keyEvent(evt)) {
         if (WebInputEvent::RawKeyDown == event.type) {
             // Suppress the next keypress event unless the focused node is a plug-in node.
             // (Flash needs these keypress events to handle non-US keyboards.)
             Element* element = focusedElement();
             if (!element || !element->renderer() || !element->renderer()->isEmbeddedObject())
                 m_suppressNextKeypressEvent = true;
@@ skipping 373 matching lines @@
     if (m_client)
         m_client->hasTouchEventHandlers(hasTouchHandlers);
 }
 
 bool WebViewImpl::hasTouchEventHandlersAt(const WebPoint& point)
 {
     // FIXME: Implement this. Note that the point must be divided by pageScaleFactor.
     return true;
 }
 
-#if !OS(DARWIN)
+#if !OS(MACOSX)
 // Mac has no way to open a context menu based on a keyboard event.
 bool WebViewImpl::sendContextMenuEvent(const WebKeyboardEvent& event)
 {
     // The contextMenuController() holds onto the last context menu that was
     // popped up on the page until a new one is created. We need to clear
     // this menu before propagating the event through the DOM so that we can
     // detect if we create a new menu for this event, since we won't create
     // a new menu if the DOM swallows the event and the defaultEventHandler does
     // not run.
     page()->contextMenuController().clearContextMenu();
@@ skipping 15 matching lines @@
     switch (event.type) {
     case WebInputEvent::Char:
         if (event.windowsKeyCode == VKEY_SPACE) {
             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);
             return scrollViewWithKeyboard(keyCode, event.modifiers);
         }
         break;
     case WebInputEvent::RawKeyDown:
         if (event.modifiers == WebInputEvent::ControlKey) {
             switch (event.windowsKeyCode) {
-#if !OS(DARWIN)
+#if !OS(MACOSX)
             case 'A':
                 focusedFrame()->executeCommand(WebString::fromUTF8("SelectAll"));
                 return true;
             case VKEY_INSERT:
             case 'C':
                 focusedFrame()->executeCommand(WebString::fromUTF8("Copy"));
                 return true;
 #endif
             // Match FF behavior in the sense that Ctrl+home/end are the only Ctrl
             // key combinations which affect scrolling. Safari is buggy in the
@@ skipping 12 matching lines @@
     default:
         break;
     }
     return false;
 }
 
 bool WebViewImpl::scrollViewWithKeyboard(int keyCode, int modifiers)
 {
     ScrollDirection scrollDirection;
     ScrollGranularity scrollGranularity;
-#if OS(DARWIN)
+#if OS(MACOSX)
     // Control-Up/Down should be PageUp/Down on Mac.
     if (modifiers & WebMouseEvent::ControlKey) {
       if (keyCode == VKEY_UP)
         keyCode = VKEY_PRIOR;
       else if (keyCode == VKEY_DOWN)
         keyCode = VKEY_NEXT;
     }
 #endif
     if (!mapKeyCodeForScroll(keyCode, &scrollDirection, &scrollGranularity))
         return false;
@@ skipping 2690 matching lines @@
     //    the initial viewport width.
     // 2. The author has disabled viewport zoom.
 
     const PageScaleConstraints& constraints = m_pageScaleConstraintsSet.pageDefinedConstraints();
 
     return fixedLayoutSize().width == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 } // namespace WebKit