The Tor Browser: gfx/skia/trunk/src/views/mac/SkOSWindow

gfx/skia/trunk/src/views/mac/SkOSWindow_Mac.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/views/mac/SkOSWindow_Mac.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkTypes.h"
 #if defined(SK_BUILD_FOR_MAC)
 #include <AGL/agl.h>
 #include <Carbon/Carbon.h>
 #include "SkCGUtils.h"
 #include "SkWindow.h"
 #include "SkCanvas.h"
 #include "SkOSMenu.h"
 #include "SkTime.h"
 #include "SkGraphics.h"
 #include <new.h>
 static void (*gPrevNewHandler)();
 extern "C" {
     static void sk_new_handler()
     {
         if (SkGraphics::SetFontCacheUsed(0))
             return;
         if (gPrevNewHandler)
             gPrevNewHandler();
         else
             sk_throw();
     }
 }
 static SkOSWindow* gCurrOSWin;
 static EventTargetRef gEventTarget;
 static EventQueueRef gCurrEventQ;
 static OSStatus MyDrawEventHandler(EventHandlerCallRef myHandler,
                                    EventRef event, void *userData) {
     // NOTE: GState is save/restored by the HIView system doing the callback,
     // so the draw handler doesn't need to do it
     OSStatus status = noErr;
     CGContextRef context;
     HIRect        bounds;
     // Get the CGContextRef
     status = GetEventParameter (event, kEventParamCGContextRef,
                                 typeCGContextRef, NULL,
                                 sizeof (CGContextRef),
                                 NULL,
                                 &context);
     if (status != noErr) {
         SkDebugf("Got error %d getting the context!\n", status);
         return status;
     }
     // Get the bounding rectangle
     HIViewGetBounds ((HIViewRef) userData, &bounds);
     gCurrOSWin->doPaint(context);
     return status;
 }
 #define SK_MacEventClass            FOUR_CHAR_CODE('SKec')
 #define SK_MacEventKind                FOUR_CHAR_CODE('SKek')
 #define SK_MacEventParamName        FOUR_CHAR_CODE('SKev')
 #define SK_MacEventSinkIDParamName    FOUR_CHAR_CODE('SKes')
 static void set_bindingside(HISideBinding* side, HIViewRef parent, HIBindingKind kind) {
     side->toView = parent;
     side->kind = kind;
     side->offset = 0;
 }
 static void set_axisscale(HIAxisScale* axis, HIViewRef parent) {
     axis->toView = parent;
     axis->kind = kHILayoutScaleAbsolute;
     axis->ratio = 1;
 }
 static void set_axisposition(HIAxisPosition* pos, HIViewRef parent, HIPositionKind kind) {
     pos->toView = parent;
     pos->kind = kind;
     pos->offset = 0;
 }
 SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd), fAGLCtx(NULL)
 {
     OSStatus    result;
     WindowRef   wr = (WindowRef)hWnd;
     HIViewRef imageView, parent;
     HIViewRef rootView = HIViewGetRoot(wr);
     HIViewFindByID(rootView, kHIViewWindowContentID, &parent);
     result = HIImageViewCreate(NULL, &imageView);
     SkASSERT(result == noErr);
     result = HIViewAddSubview(parent, imageView);
     SkASSERT(result == noErr);
     fHVIEW = imageView;
     HIViewSetVisible(imageView, true);
     HIViewPlaceInSuperviewAt(imageView, 0, 0);
     if (true) {
         HILayoutInfo layout;
         layout.version = kHILayoutInfoVersionZero;
         set_bindingside(&layout.binding.left, parent, kHILayoutBindLeft);
         set_bindingside(&layout.binding.top, parent, kHILayoutBindTop);
         set_bindingside(&layout.binding.right, parent, kHILayoutBindRight);
         set_bindingside(&layout.binding.bottom, parent, kHILayoutBindBottom);
         set_axisscale(&layout.scale.x, parent);
         set_axisscale(&layout.scale.y, parent);
         set_axisposition(&layout.position.x, parent, kHILayoutPositionLeft);
         set_axisposition(&layout.position.y, rootView, kHILayoutPositionTop);
         HIViewSetLayoutInfo(imageView, &layout);
     }
     HIImageViewSetOpaque(imageView, true);
     HIImageViewSetScaleToFit(imageView, false);
     static const EventTypeSpec  gTypes[] = {
         { kEventClassKeyboard,  kEventRawKeyDown            },
         { kEventClassKeyboard,  kEventRawKeyUp              },
         { kEventClassMouse,        kEventMouseDown                },
         { kEventClassMouse,        kEventMouseDragged            },
         { kEventClassMouse,        kEventMouseMoved            },
         { kEventClassMouse,        kEventMouseUp                },
         { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent   },
         { kEventClassWindow,    kEventWindowBoundsChanged    },
 //        { kEventClassWindow,    kEventWindowDrawContent        },
         { SK_MacEventClass,        SK_MacEventKind                }
     };
     EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler);
     int                count = SK_ARRAY_COUNT(gTypes);
     result = InstallEventHandler(GetWindowEventTarget(wr), handlerUPP,
                         count, gTypes, this, nil);
     SkASSERT(result == noErr);
     gCurrOSWin = this;
     gCurrEventQ = GetCurrentEventQueue();
     gEventTarget = GetWindowEventTarget(wr);
     static bool gOnce = true;
     if (gOnce) {
         gOnce = false;
         gPrevNewHandler = set_new_handler(sk_new_handler);
     }
 }
 void SkOSWindow::doPaint(void* ctx)
 {
 #if 0
     this->update(NULL);
     const SkBitmap& bm = this->getBitmap();
     CGImageRef img = SkCreateCGImageRef(bm);
     if (img) {
         CGRect r = CGRectMake(0, 0, bm.width(), bm.height());
         CGContextRef cg = reinterpret_cast<CGContextRef>(ctx);
         CGContextSaveGState(cg);
         CGContextTranslateCTM(cg, 0, r.size.height);
         CGContextScaleCTM(cg, 1, -1);
         CGContextDrawImage(cg, r, img);
         CGContextRestoreGState(cg);
         CGImageRelease(img);
     }
 #endif
 }
 void SkOSWindow::updateSize()
 {
     Rect    r;
     GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r);
     this->resize(r.right - r.left, r.bottom - r.top);
 #if 0
     HIRect    frame;
     HIViewRef imageView = (HIViewRef)getHVIEW();
     HIViewRef parent = HIViewGetSuperview(imageView);
     HIViewGetBounds(imageView, &frame);
     SkDebugf("------ %d bounds %g %g %g %g\n", r.right - r.left,
              frame.origin.x, frame.origin.y, frame.size.width, frame.size.height);
 #endif
 }
 void SkOSWindow::onHandleInval(const SkIRect& r)
 {
     (new SkEvent("inval-imageview", this->getSinkID()))->post();
 }
 bool SkOSWindow::onEvent(const SkEvent& evt) {
     if (evt.isType("inval-imageview")) {
         this->update(NULL);
         SkEvent query("ignore-window-bitmap");
         if (!this->doQuery(&query) || !query.getFast32()) {
             const SkBitmap& bm = this->getBitmap();
             CGImageRef img = SkCreateCGImageRef(bm);
             HIImageViewSetImage((HIViewRef)getHVIEW(), img);
             CGImageRelease(img);
         }
         return true;
     }
     return INHERITED::onEvent(evt);
 }
 void SkOSWindow::onSetTitle(const char title[])
 {
     CFStringRef str = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8);
     SetWindowTitleWithCFString((WindowRef)fHWND, str);
     CFRelease(str);
 }
 void SkOSWindow::onAddMenu(const SkOSMenu* sk_menu)
 {
 }
 static void getparam(EventRef inEvent, OSType name, OSType type, UInt32 size, void* data)
 {
     EventParamType  actualType;
     UInt32            actualSize;
     OSStatus        status;
     status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data);
     SkASSERT(status == noErr);
     SkASSERT(actualType == type);
     SkASSERT(actualSize == size);
 }
 enum {
     SK_MacReturnKey        = 36,
     SK_MacDeleteKey        = 51,
     SK_MacEndKey        = 119,
     SK_MacLeftKey        = 123,
     SK_MacRightKey        = 124,
     SK_MacDownKey        = 125,
     SK_MacUpKey            = 126,
     SK_Mac0Key          = 0x52,
     SK_Mac1Key          = 0x53,
     SK_Mac2Key          = 0x54,
     SK_Mac3Key          = 0x55,
     SK_Mac4Key          = 0x56,
     SK_Mac5Key          = 0x57,
     SK_Mac6Key          = 0x58,
     SK_Mac7Key          = 0x59,
     SK_Mac8Key          = 0x5b,
     SK_Mac9Key          = 0x5c
 };
 static SkKey raw2key(UInt32 raw)
 {
     static const struct {
         UInt32  fRaw;
         SkKey   fKey;
     } gKeys[] = {
         { SK_MacUpKey,        kUp_SkKey        },
         { SK_MacDownKey,    kDown_SkKey        },
         { SK_MacLeftKey,    kLeft_SkKey        },
         { SK_MacRightKey,   kRight_SkKey    },
         { SK_MacReturnKey,  kOK_SkKey        },
         { SK_MacDeleteKey,  kBack_SkKey        },
         { SK_MacEndKey,        kEnd_SkKey        },
         { SK_Mac0Key,       k0_SkKey        },
         { SK_Mac1Key,       k1_SkKey        },
         { SK_Mac2Key,       k2_SkKey        },
         { SK_Mac3Key,       k3_SkKey        },
         { SK_Mac4Key,       k4_SkKey        },
         { SK_Mac5Key,       k5_SkKey        },
         { SK_Mac6Key,       k6_SkKey        },
         { SK_Mac7Key,       k7_SkKey        },
         { SK_Mac8Key,       k8_SkKey        },
         { SK_Mac9Key,       k9_SkKey        }
     };
     for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++)
         if (gKeys[i].fRaw == raw)
             return gKeys[i].fKey;
     return kNONE_SkKey;
 }
 static void post_skmacevent()
 {
     EventRef    ref;
     OSStatus    status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref);
     SkASSERT(status == noErr);
 #if 0
     status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
     SkASSERT(status == noErr);
     status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
     SkASSERT(status == noErr);
 #endif
     EventTargetRef target = gEventTarget;
     SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target);
     SkASSERT(status == noErr);
     status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard);
     SkASSERT(status == noErr);
     ReleaseEvent(ref);
 }
 pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData )
 {
     SkOSWindow* win = (SkOSWindow*)userData;
     OSStatus    result = eventNotHandledErr;
     UInt32        wClass = GetEventClass(inEvent);
     UInt32        wKind = GetEventKind(inEvent);
     gCurrOSWin = win;    // will need to be in TLS. Set this so PostEvent will work
     switch (wClass) {
         case kEventClassMouse: {
             Point   pt;
             getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt);
             SetPortWindowPort((WindowRef)win->getHWND());
             GlobalToLocal(&pt);
             switch (wKind) {
                 case kEventMouseDown:
                     if (win->handleClick(pt.h, pt.v, Click::kDown_State)) {
                         result = noErr;
                     }
                     break;
                 case kEventMouseMoved:
                     // fall through
                 case kEventMouseDragged:
                     (void)win->handleClick(pt.h, pt.v, Click::kMoved_State);
                   //  result = noErr;
                     break;
                 case kEventMouseUp:
                     (void)win->handleClick(pt.h, pt.v, Click::kUp_State);
                   //  result = noErr;
                     break;
                 default:
                     break;
             }
             break;
         }
         case kEventClassKeyboard:
             if (wKind == kEventRawKeyDown) {
                 UInt32  raw;
                 getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw);
                 SkKey key = raw2key(raw);
                 if (key != kNONE_SkKey)
                     (void)win->handleKey(key);
             } else if (wKind == kEventRawKeyUp) {
                 UInt32 raw;
                 getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw);
                 SkKey key = raw2key(raw);
                 if (key != kNONE_SkKey)
                     (void)win->handleKeyUp(key);
             }
             break;
         case kEventClassTextInput:
             if (wKind == kEventTextInputUnicodeForKeyEvent) {
                 UInt16  uni;
                 getparam(inEvent, kEventParamTextInputSendText, typeUnicodeText, sizeof(uni), &uni);
                 win->handleChar(uni);
             }
             break;
         case kEventClassWindow:
             switch (wKind) {
                 case kEventWindowBoundsChanged:
                     win->updateSize();
                     break;
                 case kEventWindowDrawContent: {
                     CGContextRef cg;
                     result = GetEventParameter(inEvent,
                                                kEventParamCGContextRef,
                                                typeCGContextRef,
                                                NULL,
                                                sizeof (CGContextRef),
                                                NULL,
                                                &cg);
                     if (result != 0) {
                         cg = NULL;
                     }
                     win->doPaint(cg);
                     break;
                 }
                 default:
                     break;
             }
             break;
         case SK_MacEventClass: {
             SkASSERT(wKind == SK_MacEventKind);
             if (SkEvent::ProcessEvent()) {
                     post_skmacevent();
             }
     #if 0
             SkEvent*        evt;
             SkEventSinkID    sinkID;
             getparam(inEvent, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt);
             getparam(inEvent, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID);
     #endif
             result = noErr;
             break;
         }
         default:
             break;
     }
     if (result == eventNotHandledErr) {
         result = CallNextEventHandler(inHandler, inEvent);
     }
     return result;
 }
 ///////////////////////////////////////////////////////////////////////////////////////
 void SkEvent::SignalNonEmptyQueue()
 {
     post_skmacevent();
 //    SkDebugf("signal nonempty\n");
 }
 static TMTask    gTMTaskRec;
 static TMTask*    gTMTaskPtr;
 static void sk_timer_proc(TMTask* rec)
 {
     SkEvent::ServiceQueueTimer();
 //    SkDebugf("timer task fired\n");
 }
 void SkEvent::SignalQueueTimer(SkMSec delay)
 {
     if (gTMTaskPtr)
     {
         RemoveTimeTask((QElem*)gTMTaskPtr);
         DisposeTimerUPP(gTMTaskPtr->tmAddr);
         gTMTaskPtr = nil;
     }
     if (delay)
     {
         gTMTaskPtr = &gTMTaskRec;
         memset(gTMTaskPtr, 0, sizeof(gTMTaskRec));
         gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc);
         OSErr err = InstallTimeTask((QElem*)gTMTaskPtr);
 //        SkDebugf("installtimetask of %d returned %d\n", delay, err);
         PrimeTimeTask((QElem*)gTMTaskPtr, delay);
     }
 }
 #define USE_MSAA 0
 AGLContext create_gl(WindowRef wref)
 {
     GLint major, minor;
     AGLContext ctx;
     aglGetVersion(&major, &minor);
     SkDebugf("---- agl version %d %d\n", major, minor);
     const GLint pixelAttrs[] = {
         AGL_RGBA,
         AGL_STENCIL_SIZE, 8,
 #if USE_MSAA
         AGL_SAMPLE_BUFFERS_ARB, 1,
         AGL_MULTISAMPLE,
         AGL_SAMPLES_ARB, 8,
 #endif
         AGL_ACCELERATED,
         AGL_DOUBLEBUFFER,
         AGL_NONE
     };
     AGLPixelFormat format = aglChoosePixelFormat(NULL, 0, pixelAttrs);
     //AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs);
     SkDebugf("----- agl format %p\n", format);
     ctx = aglCreateContext(format, NULL);
     SkDebugf("----- agl context %p\n", ctx);
     aglDestroyPixelFormat(format);
     static const GLint interval = 1;
     aglSetInteger(ctx, AGL_SWAP_INTERVAL, &interval);
     aglSetCurrentContext(ctx);
     return ctx;
 }
 bool SkOSWindow::attach(SkBackEndTypes /* attachType */)
 {
     if (NULL == fAGLCtx) {
         fAGLCtx = create_gl((WindowRef)fHWND);
         if (NULL == fAGLCtx) {
             return false;
         }
     }
     GLboolean success = true;
     int width, height;
     success = aglSetWindowRef((AGLContext)fAGLCtx, (WindowRef)fHWND);
     width = this->width();
     height = this->height();
     GLenum err = aglGetError();
     if (err) {
         SkDebugf("---- aglSetWindowRef %d %d %s [%d %d]\n", success, err,
                  aglErrorString(err), width, height);
     }
     if (success) {
         glViewport(0, 0, width, height);
         glClearColor(0, 0, 0, 0);
         glClearStencil(0);
         glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
     }
     return success;
 }
 void SkOSWindow::detach() {
     aglSetWindowRef((AGLContext)fAGLCtx, NULL);
 }
 void SkOSWindow::present() {
     aglSwapBuffers((AGLContext)fAGLCtx);
 }
 #endif

The Tor Browser / annotate

gfx/skia/trunk/src/views/mac/SkOSWindow_Mac.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/views/mac/SkOSWindow_Mac.cpp