O3D Mac: Add CoreAnimation support

plugin/mac/main_mac.mm

 /*
  * Copyright 2009, 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.
@@ skipping 30 matching lines @@
 #include "base/scoped_ptr.h"
 
 #import <Cocoa/Cocoa.h>
 #include <Carbon/Carbon.h>
 #include <OpenGL/OpenGL.h>
 #include <AGL/agl.h>
 #include <AGL/aglRenderers.h>
 
 #include "core/cross/event.h"
 #include "statsreport/metrics.h"
+#include "plugin/cross/config.h"
 #include "plugin/cross/plugin_logging.h"
 #include "plugin/cross/plugin_metrics.h"
 #include "plugin/cross/o3d_glue.h"
 #include "plugin/cross/out_of_memory.h"
 #include "plugin/cross/whitelist.h"
 #include "plugin/mac/plugin_mac.h"
 #include "plugin/mac/graphics_utils_mac.h"
+#import "plugin/mac/o3d_layer.h"
+
 
 #if !defined(O3D_INTERNAL_PLUGIN)
 o3d::PluginLogging* g_logger = NULL;
 bool g_logging_initialized = false;
 #endif
 
 using glue::_o3d::PluginObject;
 using glue::StreamManager;
 using o3d::Bitmap;
 using o3d::DisplayWindowMac;
 using o3d::Event;
 using o3d::Renderer;
 
 namespace {
 // We would normally make this a stack variable in main(), but in a
 // plugin, that's not possible, so we make it a global. When the DLL is loaded
 // this it gets constructed and when it is unlooaded it is destructed. Note
 // that this cannot be done in NP_Initialize and NP_Shutdown because those
 // calls do not necessarily signify the DLL being loaded and unloaded. If the
 // DLL is not unloaded then the values of global variables are preserved.
 base::AtExitManager g_at_exit_manager;
 
 #define CFTIMER
 // #define DEFERRED_DRAW_ON_NULLEVENTS
 
+  
+// Helper that extracts the O3DLayer obj c object from the PluginObject
+// and coerces it to the right type.  The code can't live in the PluginObject
+// since it's c++ code and doesn't know about objective c types, and it saves
+// lots of casts elsewhere in the code.
+static O3DLayer* ObjO3DLayer(PluginObject* obj) {
+  return static_cast<O3DLayer*>(obj ? obj->gl_layer_ : nil);
+}
+
 void DrawPlugin(PluginObject* obj, bool send_callback, CGContextRef context) {
   obj->client()->RenderClient(send_callback);
   Renderer* renderer = obj->renderer();
   if (obj->IsOffscreenRenderingEnabled() && renderer && context) {
     DCHECK_EQ(obj->drawing_model_, NPDrawingModelCoreGraphics);
     DCHECK(obj->mac_cgl_pbuffer_);
     // We need to read back the framebuffer and draw it to the screen using
     // CoreGraphics.
     renderer->StartRendering();
     Bitmap::Ref bitmap = obj->GetOffscreenBitmap();
@@ skipping 368 matching lines @@
   WindowRef fullscreen_window = obj->GetFullscreenMacWindow();
   bool handled = false;
 
   if (g_logger) g_logger->UpdateLogging();
 
   obj->MacEventReceived();
   switch (the_event->type) {
     case NPCocoaEventDrawRect:
       // We need to call the render callback from here if we are rendering
       // off-screen because it doesn't get called anywhere else.
-      DrawPlugin(obj,
-                 obj->IsOffscreenRenderingEnabled(),
-                 the_event->data.draw.context);
+      if (obj->drawing_model_ == NPDrawingModelCoreAnimation) {
+        O3DLayer* layer = ObjO3DLayer(obj);
+        if (layer) {
+          [layer setNeedsDisplay];
+        }
+      } else {
+        DrawPlugin(obj,
+                   obj->IsOffscreenRenderingEnabled(),
+                   the_event->data.draw.context);
+      }
       handled = true;
       break;
     case NPCocoaEventMouseDown:
     case NPCocoaEventMouseUp:
     case NPCocoaEventMouseMoved:
     case NPCocoaEventMouseDragged:
     case NPCocoaEventMouseEntered:
     case NPCocoaEventMouseExited:
     case NPCocoaEventScrollWheel:
       HandleCocoaMouseEvent(obj, the_event);
@@ skipping 93 matching lines @@
               logging::APPEND_TO_OLD_LOG_FILE);
 
   DLOG(INFO) << "NP_Initialize";
 
   o3d::SetupOutOfMemoryHandler();
 #endif  // O3D_INTERNAL_PLUGIN
 
   return NPERR_NO_ERROR;
 }
 
+// When to prefer Core Animation, currently that's only on Safari and 10.6+
+// but that will change as we use this model in more browsers.
+static bool PreferCoreAnimation() {
+  bool isSafari = o3d::metric_browser_type.value() == o3d::BROWSER_NAME_SAFARI;
+  return (o3d::IsMacOSTenSixOrHigher() && isSafari);
+}
+  
 // Negotiates the best plugin event model, sets the browser to use that,
 // and updates the PluginObject so we can remember which one we chose.
 // We favor the newer Cocoa-based model, but can cope with browsers that
 // only support the original event model, or indeed can't even understand
 // what we are asking for.
 // However, right at the minute, we shun the Cocoa event model because its
 // NPP_SetWindow messages don't contain a WindowRef or NSWindow so we would
 // not get enough info to create our AGL context. We'll go back to
 // preferring Cocoa once we have worked out how to deal with that.
 // Cannot actually fail -
@@ skipping 24 matching lines @@
   // Now we've collected our data, the decision phase begins.
 
   // If we didn't successfully get TRUE for either question, the browser
   // just does not know about the new switchable event models, so must only
   // support the old Carbon event model.
   if (!(supportsCocoaEventModel || supportsCarbonEventModel)) {
     supportsCarbonEventModel = TRUE;
     obj->event_model_ = NPEventModelCarbon;
   }
 
-  // Default to Carbon event model, because the new version of the
-  // Cocoa event model spec does not supply sufficient window
-  // information in its Cocoa NPP_SetWindow calls for us to bind an
-  // AGL context to the browser window.
-  model_to_use =
-      (supportsCarbonEventModel) ? NPEventModelCarbon : NPEventModelCocoa;
-  if (o3d::gIsChrome) {
-    if (supportsCocoaEventModel) {
-      model_to_use = NPEventModelCocoa;
+  
+  if (PreferCoreAnimation()) {  
+    // If we're building for Core Animation then we prefer the Cocoa event 
+    // model.
+    model_to_use =
+    (supportsCocoaEventModel) ? NPEventModelCocoa : NPEventModelCarbon;
+    NPN_SetValue(instance, NPPVpluginEventModel,
+                 reinterpret_cast<void*>(model_to_use));
+  } else {
+    // Default to Carbon event model, because the new version of the
+    // Cocoa event model spec does not supply sufficient window
+    // information in its Cocoa NPP_SetWindow calls for us to bind an
+    // AGL context to the browser window.
+    model_to_use =
+    (supportsCarbonEventModel) ? NPEventModelCarbon : NPEventModelCocoa;
+    if (o3d::gIsChrome) {
+      if (supportsCocoaEventModel) {
+        model_to_use = NPEventModelCocoa;
+      }
     }
   }
   NPN_SetValue(instance, NPPVpluginEventModel,
                reinterpret_cast<void*>(model_to_use));
+
+
   obj->event_model_ = model_to_use;
 }
 
 
 // Negotiates the best plugin drawing model, sets the browser to use that,
 // and updates the PluginObject so we can remember which one we chose.
 // Returns NPERR_NO_ERROR (0) if successful, otherwise an NPError code.
 NPError Mac_SetBestDrawingModel(NPP instance, PluginObject* obj) {
   NPError err = NPERR_NO_ERROR;
   NPBool supportsCoreGraphics = FALSE;
-  NPBool supportsOpenGL = FALSE;
   NPBool supportsQuickDraw = FALSE;
+  NPBool supportsCoreAnimation = FALSE;
   NPDrawingModel drawing_model = NPDrawingModelQuickDraw;
 
-  // test for direct OpenGL support
-  err = NPN_GetValue(instance,
-                     NPNVsupportsOpenGLBool,
-                     &supportsOpenGL);
-  if (err != NPERR_NO_ERROR)
-    supportsOpenGL = FALSE;
-
   // test for QuickDraw support
   err = NPN_GetValue(instance,
                      NPNVsupportsQuickDrawBool,
                      &supportsQuickDraw);
   if (err != NPERR_NO_ERROR)
     supportsQuickDraw = FALSE;
 
   // Test for Core Graphics support
   err = NPN_GetValue(instance,
                      NPNVsupportsCoreGraphicsBool,
                      &supportsCoreGraphics);
   if (err != NPERR_NO_ERROR)
     supportsCoreGraphics = FALSE;
 
+  err = NPN_GetValue(instance,
+                     NPNVsupportsCoreAnimationBool,
+                     &supportsCoreAnimation);
+  if (err != NPERR_NO_ERROR)
+    supportsCoreAnimation = FALSE;
+
+  // In order of preference. Preference is now determined by compatibility,
+  // not by modernity, and so is the opposite of the order I first used.
+  if (supportsQuickDraw && !(obj->event_model_ == NPEventModelCocoa)) {
+    drawing_model = NPDrawingModelQuickDraw;
+  } else if (supportsCoreAnimation && PreferCoreAnimation()) {
+    drawing_model = NPDrawingModelCoreAnimation;
   // In the Chrome browser we currently want to prefer the CoreGraphics
   // drawing model, read back the frame buffer into system memory and draw
   // the results to the screen using CG.
   //
-  // TODO(maf): Once support for the CoreAnimation drawing model is
-  // integrated into O3D, we will want to revisit this logic.
-  if (o3d::gIsChrome && supportsCoreGraphics) {
+  } else if (o3d::gIsChrome && supportsCoreGraphics) {
     drawing_model = NPDrawingModelCoreGraphics;
   } else {
-    // In order of preference. Preference is now determined by compatibility,
-    // not by modernity, and so is the opposite of the order I first used.
-    if (supportsQuickDraw && !(obj->event_model_ == NPEventModelCocoa)) {
-      drawing_model = NPDrawingModelQuickDraw;
-    } else if (supportsCoreGraphics) {
+    if (supportsCoreGraphics) {
       drawing_model = NPDrawingModelCoreGraphics;
-    } else if (supportsOpenGL) {
-      drawing_model = NPDrawingModelOpenGL;
     } else {
       // This case is for browsers that didn't even understand the question
       // eg FF2, so drawing models are not supported, just assume QuickDraw.
       obj->drawing_model_ = NPDrawingModelQuickDraw;
       return NPERR_NO_ERROR;
     }
   }      
 
   err = NPN_SetValue(instance, NPPVpluginDrawingModel,
                      reinterpret_cast<void*>(drawing_model));
@@ skipping 66 matching lines @@
 
   o3d::ShutdownBreakpad();
 #endif  // O3D_INTERNAL_PLUGIN
 
   return NPERR_NO_ERROR;
 }
 
 }  // namespace o3d / extern "C"
 
 
+
 namespace o3d {
 
 NPError PlatformNPPGetValue(NPP instance, NPPVariable variable, void *value) {
+  PluginObject* obj = static_cast<PluginObject*>(instance->pdata);
+
+  switch (variable) {
+    case NPPVpluginCoreAnimationLayer:
+      if (!ObjO3DLayer(obj)) {
+        // Setup layer
+        O3DLayer* gl_layer = [[[O3DLayer alloc] init] retain];
+
+        gl_layer.autoresizingMask =
+            kCALayerWidthSizable + kCALayerHeightSizable;
+        obj->gl_layer_ = gl_layer;
+
+        [gl_layer setPluginObject:obj];
+      }
+      // Make sure to return a retained layer
+      *(CALayer**)value = ObjO3DLayer(obj);
+      return NPERR_NO_ERROR;
+      break;
+    default:
+      return NPERR_INVALID_PARAM;
+  }
+
   return NPERR_INVALID_PARAM;
 }
 
 bool HandleMacEvent(EventRecord* the_event, NPP instance) {
   PluginObject* obj = static_cast<PluginObject*>(instance->pdata);
   bool handled = false;
   WindowRef fullscreen_window = obj->GetFullscreenMacWindow();
 
   if (g_logger) g_logger->UpdateLogging();
 
@@ skipping 81 matching lines @@
 }
 
 NPError NPP_New(NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
                 char* argn[], char* argv[], NPSavedData* saved) {
   HANDLE_CRASHES;
 
   NPError err = NPERR_NO_ERROR;
 
 #if !defined(O3D_INTERNAL_PLUGIN)
   if (!g_logging_initialized) {
-    GetUserAgentMetrics(instance);
+    o3d::GetUserAgentMetrics(instance);
     GetUserConfigMetrics();
     // Create usage stats logs object
     g_logger = o3d::PluginLogging::InitializeUsageStatsLogging();
     g_logging_initialized = true;
   }
 #endif  // O3D_INTERNAL_PLUGIN
 
   if (!IsDomainAuthorized(instance)) {
     return NPERR_INVALID_URL;
   }
 
   PluginObject* pluginObject = glue::_o3d::PluginObject::Create(
       instance);
   instance->pdata = pluginObject;
   glue::_o3d::InitializeGlue(instance);
   pluginObject->Init(argc, argn, argv);
 
   Mac_SetBestEventModel(instance,
                         static_cast<PluginObject*>(instance->pdata));
 
   err = Mac_SetBestDrawingModel(
       instance, static_cast<PluginObject*>(instance->pdata));
   if (err != NPERR_NO_ERROR)
     return err;
+#ifdef CFTIMER
+  if (pluginObject->drawing_model_ == NPDrawingModelCoreAnimation) {
+    o3d::gRenderTimer.AddInstance(instance);
+  }
+#endif
   return NPERR_NO_ERROR;
 }
 
 NPError NPP_Destroy(NPP instance, NPSavedData** save) {
   HANDLE_CRASHES;
   PluginObject* obj = static_cast<PluginObject*>(instance->pdata);
   if (obj) {
 #if defined(CFTIMER)
     o3d::gRenderTimer.RemoveInstance(instance);
 #endif
@@ skipping 11 matching lines @@
 }
 
 NPError NPP_SetWindow(NPP instance, NPWindow* window) {
   HANDLE_CRASHES;
   PluginObject* obj = static_cast<PluginObject*>(instance->pdata);
   WindowRef new_window = NULL;
 
   assert(window != NULL);
 
   if (window->window == NULL &&
-      obj->drawing_model_ != NPDrawingModelCoreGraphics)
+      obj->drawing_model_ != NPDrawingModelCoreGraphics &&
+      obj->drawing_model_!= NPDrawingModelCoreAnimation) {
     return NPERR_NO_ERROR;
+  }
 
   obj->last_plugin_loc_.h = window->x;
   obj->last_plugin_loc_.v = window->y;
 
   switch (obj->drawing_model_) {
-    case NPDrawingModelOpenGL: {
-      NP_GLContext* np_gl = reinterpret_cast<NP_GLContext*>(window->window);
-      if (obj->event_model_ == NPEventModelCocoa) {
-        NSWindow * ns_window = reinterpret_cast<NSWindow*>(np_gl->window);
-        new_window = reinterpret_cast<WindowRef>([ns_window windowRef]);
-      } else {
-        new_window = np_gl->window;
-      }
-      obj->mac_2d_context_ = NULL;
-      obj->mac_cgl_context_ = np_gl->context;
-      break;
+    case NPDrawingModelCoreAnimation: {
+      O3DLayer* o3dLayer = ObjO3DLayer(obj);
+      [o3dLayer setWidth: window->width height: window->height];
+      return NPERR_NO_ERROR;
     }
     case NPDrawingModelCoreGraphics: {
       // Safari 4 sets window->window to NULL when in Cocoa event mode.
       if (window->window != NULL) {
         NP_CGContext* np_cg = reinterpret_cast<NP_CGContext*>(window->window);
         if (obj->event_model_ == NPEventModelCocoa) {
           NSWindow * ns_window = reinterpret_cast<NSWindow*>(np_cg->window);
           new_window = reinterpret_cast<WindowRef>([ns_window windowRef]);
         } else {
           new_window = static_cast<OpaqueWindowPtr*>(np_cg->window);
@@ skipping 24 matching lines @@
   bool window_changed = new_window != obj->mac_window_;
 
   // Whether we already had a window before this call.
   bool had_a_window = obj->mac_window_ != NULL;
 
   // Whether we already had a pbuffer before this call.
   bool had_a_pbuffer = obj->mac_cgl_pbuffer_ != NULL;
 
   obj->mac_window_ = new_window;
 
-  if (obj->drawing_model_ == NPDrawingModelOpenGL) {
-    CGLSetCurrentContext(obj->mac_cgl_context_);
+  if (obj->drawing_model_ == NPDrawingModelCoreAnimation) {
+    if (obj->mac_cgl_context_) {
+      CGLSetCurrentContext(obj->mac_cgl_context_);
+    }
   } else if (obj->drawing_model_ == NPDrawingModelCoreGraphics &&
              o3d::gIsChrome &&
              obj->mac_cgl_pbuffer_ == NULL) {
     // This code path is only taken for Chrome. We initialize things with a
     // CGL context rendering to a 1x1 pbuffer. Later we use the O3D
     // RenderSurface APIs to set up the framebuffer object which is used
     // for rendering.
     static const CGLPixelFormatAttribute attribs[] = {
       (CGLPixelFormatAttribute) kCGLPFAPBuffer,
       (CGLPixelFormatAttribute) 0
@@ skipping 216 matching lines @@
   // Renderer is already initialized from a previous call to this function,
   // just update size and position and return.
   if (had_a_window) {
     if (obj->renderer()) {
       obj->renderer()->SetClientOriginOffset(gl_x_origin, gl_y_origin);
       obj->Resize(window->width, window->height);
     }
     return NPERR_NO_ERROR;
   }
 
+  if (obj->renderer())
+    return NPERR_NO_ERROR;
+
   // Create and assign the graphics context.
   o3d::DisplayWindowMac default_display;
   default_display.set_agl_context(obj->mac_agl_context_);
   default_display.set_cgl_context(obj->mac_cgl_context_);
 
   obj->CreateRenderer(default_display);
 
   // if the renderer cannot be created (maybe the features are not supported)
   // then we can proceed no further
   if (!obj->renderer()) {
@@ skipping 49 matching lines @@
   if (obj->event_model_ == NPEventModelCarbon) {
     EventRecord* theEvent = static_cast<EventRecord*>(event);
     return HandleMacEvent(theEvent, instance) ? 1 : 0;
   } else if (obj->event_model_ == NPEventModelCocoa){
     return HandleCocoaEvent(instance, (NPCocoaEvent*)event) ? 1 : 0;
   }
   return 0;
 }
 
 }  //  namespace o3d