- Check for a NULL PluginObject at all NPAPI entry points. This fixes a crash in Chrome where ...

plugin/win/main_win.cc

 /*
  * 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 21 matching lines @@
 
 // This file implements the platform specific parts of the plugin for
 // the Windows platform.
 
 #include "plugin/cross/main.h"
 
 #include <windows.h>
 #include <windowsx.h>
 #include <shellapi.h>
 
-#include "base/at_exit.h"
-#include "base/command_line.h"
-#include "base/file_util.h"
 #include "base/logging.h"
-#include "base/ref_counted.h"
 #include "core/cross/display_mode.h"
 #include "core/cross/event.h"
-#include "plugin/cross/plugin_logging.h"
-#include "plugin/cross/out_of_memory.h"
-#include "plugin/cross/whitelist.h"
-#include "statsreport/metrics.h"
+#include "core/win/display_window_win.h"
 #include "v8/include/v8.h"
-#include "breakpad/win/bluescreen_detector.h"
+#if !defined(O3D_INTERNAL_PLUGIN)
+#include "breakpad/win/exception_handler_win32.h"
+#endif
 
 using glue::_o3d::PluginObject;
 using glue::StreamManager;
 using o3d::DisplayWindowWindows;
 using o3d::Event;
 
 namespace {
 // The instance handle of the O3D DLL.
 HINSTANCE g_module_instance;
 }  // namespace anonymous
 
 #if !defined(O3D_INTERNAL_PLUGIN)
-
-o3d::PluginLogging* g_logger = NULL;
-bool g_logging_initialized = false;
-o3d::BluescreenDetector *g_bluescreen_detector = NULL;
+// Used for breakpad crash handling
+static ExceptionManager *g_exception_manager = NULL;
 
 extern "C" BOOL WINAPI DllMain(HINSTANCE instance,
                                DWORD reason,
                                LPVOID reserved) {
   g_module_instance = instance;
 
   if (reason == DLL_PROCESS_DETACH) {
      // Teardown V8 when the plugin dll is unloaded.
      // NOTE: NP_Shutdown would have been a good place for this code but
      //       unfortunately it looks like it gets called even when the dll
      //       isn't really unloaded.  This is a problem since after calling
      //       V8::Dispose(), V8 cannot be initialized again.
      bool v8_disposed = v8::V8::Dispose();
      if (!v8_disposed)
        DLOG(ERROR) << "Failed to release V8 resources.";
      return true;
   }
   return true;
 }
 #endif  // O3D_INTERNAL_PLUGIN
 
 namespace {
 const wchar_t* const kO3DWindowClassName = L"O3DWindowClass";
 
 void CleanupAllWindows(PluginObject *obj);
 
-// 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;
-
 static int HandleKeyboardEvent(PluginObject *obj,
                                HWND hWnd,
                                UINT Msg,
                                WPARAM wParam,
                                LPARAM lParam) {
   DCHECK(obj);
   DCHECK(obj->client());
   Event::Type type;
   // First figure out which kind of event to create, and do any event-specific
   // processing that can be done prior to creating it.
@@ skipping 359 matching lines @@
       // Tell windows we don't need the background cleared.
       return 1;
     }
 
     case WM_TIMER: {
       if (reentrance_count.get() > 1) {
         break;  // Ignore this message; we're reentrant.
       }
 
 #if !defined(O3D_INTERNAL_PLUGIN)
-      // TODO: Only logging for windows until we figure out the proper
-      //            mac way
       if (g_logger) g_logger->UpdateLogging();
 #endif
 
       // If rendering continuously, invalidate the window and force a paint if
       // it is visible. The paint invalidates the renderer and Tick will later
       // repaint the window.
       if (obj->client()->NeedsContinuousRender()) {
         InvalidateRect(obj->GetHWnd(), NULL, FALSE);
         UpdateWindow(obj->GetHWnd());
       }
@@ skipping 150 matching lines @@
   window_class.lpszClassName = kO3DWindowClassName;
   // We use CS_OWNDC in case we are rendering OpenGL into this window.
   window_class.style = CS_DBLCLKS | CS_OWNDC;
   return RegisterClassEx(&window_class) != 0;
 }
 
 void UnregisterO3DWindowClass() {
   UnregisterClass(kO3DWindowClassName, g_module_instance);
 }
 
-NPError InitializePlugin() {
-#if !defined(O3D_INTERNAL_PLUGIN)
-  if (!o3d::SetupOutOfMemoryHandler())
-    return NPERR_MODULE_LOAD_FAILED_ERROR;
-
-  // Setup crash handler
-  if (!g_exception_manager) {
-    g_exception_manager = new ExceptionManager(false);
-    g_exception_manager->StartMonitoring();
-  }
-
-  // Turn on the logging.
-  CommandLine::Init(0, NULL);
-
-  FilePath log;
-  file_util::GetTempDir(&log);
-  log.Append(L"debug.log");
-
-  InitLogging(log.value().c_str(),
-              logging::LOG_TO_BOTH_FILE_AND_SYSTEM_DEBUG_LOG,
-              logging::DONT_LOCK_LOG_FILE,
-              logging::APPEND_TO_OLD_LOG_FILE);
-#endif  // O3D_INTERNAL_PLUGIN
-
-  DLOG(INFO) << "NP_Initialize";
-
-  if (!RegisterO3DWindowClass())
-    return NPERR_MODULE_LOAD_FAILED_ERROR;
-
-  return NPERR_NO_ERROR;
-}
-
 void CleanupAllWindows(PluginObject *obj) {
   if (obj->GetContentHWnd()) {
     ::KillTimer(obj->GetContentHWnd(), 0);
     PluginObject::ClearPluginProperty(obj->GetContentHWnd());
     ::PostMessage(obj->GetContentHWnd(), kDestroyWindowMessageID, 0, 0);
     obj->SetContentHWnd(NULL);
   }
 
   if (obj->GetPluginHWnd()) {
     // Restore the original WNDPROC on the plugin window so that we
@@ skipping 47 matching lines @@
   if (GetMonitorInfo(monitor, &monitor_info)) {
     *rect = monitor_info.rcMonitor;
     return true;
   } else {
     return false;
   }
 }
 
 }  // namespace anonymous
 
-#if defined(O3D_INTERNAL_PLUGIN)
 namespace o3d {
-#else
-extern "C" {
-#endif
 
-NPError OSCALL NP_Initialize(NPNetscapeFuncs *browserFuncs) {
-  HANDLE_CRASHES;
-
-  NPError retval = InitializeNPNApi(browserFuncs);
-  if (retval != NPERR_NO_ERROR) return retval;
-  return InitializePlugin();
+NPError PlatformPreNPInitialize() {
+#if !defined(O3D_INTERNAL_PLUGIN)
+  // Setup crash handler
+  if (!g_exception_manager) {
+    g_exception_manager = new ExceptionManager(false);
+    g_exception_manager->StartMonitoring();
+  }
+#endif  // O3D_INTERNAL_PLUGIN
+  return NPERR_NO_ERROR;
 }
 
-NPError OSCALL NP_Shutdown(void) {
-  HANDLE_CRASHES;
-  DLOG(INFO) << "NP_Shutdown";
+NPError PlatformPostNPInitialize() {
+  if (!RegisterO3DWindowClass())
+    return NPERR_MODULE_LOAD_FAILED_ERROR;
 
+  return NPERR_NO_ERROR;
+}
+
+NPError PlatformPreNPShutdown() {
+  // TODO(tschmelcher): Is there a reason we need to do this before the main
+  // shutdown tasks? If not, we can axe the PlatformPreNPShutdown() function.
   UnregisterO3DWindowClass();
+  return NPERR_NO_ERROR;
+}
 
+NPError PlatformPostNPShutdown() {
 #if !defined(O3D_INTERNAL_PLUGIN)
-
-  if (g_logger) {
-    // Do a last sweep to aggregate metrics before we shut down
-    g_logger->ProcessMetrics(true, false, false);
-    delete g_logger;
-    g_logger = NULL;
-    g_logging_initialized = false;
-    stats_report::g_global_metrics.Uninitialize();
-  }
-
-  CommandLine::Reset();
-
   // TODO : This is commented out until we can determine if
   // it's safe to shutdown breakpad at this stage (Gears, for
   // example, never deletes...)
   // Shutdown breakpad
   // delete g_exception_manager;
-
-  // Strictly speaking, on windows, it's not really necessary to call
-  // Stop(), but we do so for completeness
-  if (g_bluescreen_detector) {
-    g_bluescreen_detector->Stop();
-    delete g_bluescreen_detector;
-    g_bluescreen_detector = NULL;
-  }
-
-#endif  // O3D_INTERNAL_PLUGIN
-
-  return NPERR_NO_ERROR;
-}
-}  // extern "C" / namespace o3d
-
-namespace o3d {
-
-NPError NPP_New(NPMIMEType pluginType,
-                NPP instance,
-                uint16 mode,
-                int16 argc,
-                char *argn[],
-                char *argv[],
-                NPSavedData *saved) {
-  HANDLE_CRASHES;
-
-#if !defined(O3D_INTERNAL_PLUGIN)
-  if (!g_logging_initialized) {
-    // Get user config metrics. These won't be stored though unless the user
-    // opts-in for usagestats logging
-    GetUserAgentMetrics(instance);
-    GetUserConfigMetrics();
-    // Create usage stats logs object
-    g_logger = o3d::PluginLogging::InitializeUsageStatsLogging();
-    if (g_logger) {
-      // Setup blue-screen detection
-      g_bluescreen_detector = new o3d::BluescreenDetector();
-      g_bluescreen_detector->Start();
-    }
-    g_logging_initialized = true;
-  }
 #endif
 
-  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);
-  return NPERR_NO_ERROR;
-}
-
-NPError NPP_Destroy(NPP instance, NPSavedData **save) {
-  HANDLE_CRASHES;
-  PluginObject *obj = static_cast<PluginObject*>(instance->pdata);
-  if (obj) {
-    if (obj->GetHWnd()) {
-      CleanupAllWindows(obj);
-    }
-
-    obj->TearDown();
-    NPN_ReleaseObject(obj);
-    instance->pdata = NULL;
-  }
-
   return NPERR_NO_ERROR;
 }
 
-NPError PlatformNPPGetValue(NPP instance, NPPVariable variable, void *value) {
+NPError PlatformNPPNew(NPP instance, PluginObject *obj) {
+  return NPERR_NO_ERROR;
+}
+
+NPError PlatformNPPDestroy(NPP instance, PluginObject *obj) {
+  if (obj->GetHWnd()) {
+    CleanupAllWindows(obj);
+  }
+
+  obj->TearDown();
+  return NPERR_NO_ERROR;
+}
+
+NPError PlatformNPPGetValue(PluginObject *obj,
+                            NPPVariable variable,
+                            void *value) {
   return NPERR_INVALID_PARAM;
 }
 
-NPError NPP_SetWindow(NPP instance, NPWindow *window) {
-  HANDLE_CRASHES;
-  PluginObject *obj = static_cast<PluginObject*>(instance->pdata);
-
+NPError PlatformNPPSetWindow(NPP instance,
+                             PluginObject *obj,
+                             NPWindow *window) {
   HWND hWnd = static_cast<HWND>(window->window);
   if (!hWnd) {
     // Chrome calls us this way before NPP_Destroy.
     if (obj->GetHWnd()) {
       CleanupAllWindows(obj);
     }
     return NPERR_NO_ERROR;
   }
 
   if (obj->GetPluginHWnd() == hWnd) {
@@ skipping 59 matching lines @@
   obj->client()->Init();
 
   // we set the timer to 10ms or 100fps. At the time of this comment
   // the renderer does a vsync the max fps it will run will be the refresh
   // rate of the monitor or 100fps, which ever is lower.
   ::SetTimer(obj->GetHWnd(), 0, 10, NULL);
 
   return NPERR_NO_ERROR;
 }
 
-// Called when the browser has finished attempting to stream data to
-// a file as requested. If fname == NULL the attempt was not successful.
-void NPP_StreamAsFile(NPP instance, NPStream *stream, const char *fname) {
-  HANDLE_CRASHES;
-  PluginObject *obj = static_cast<PluginObject*>(instance->pdata);
-  StreamManager *stream_manager = obj->stream_manager();
-
+void PlatformNPPStreamAsFile(StreamManager *stream_manager,
+                             NPStream *stream,
+                             const char *fname) {
   stream_manager->SetStreamFile(stream, fname);
 }
 
-int16 NPP_HandleEvent(NPP instance, void *event) {
-  HANDLE_CRASHES;
+int16 PlatformNPPHandleEvent(NPP instance, PluginObject *obj, void *event) {
   return 0;
 }
+
 }  // namespace o3d
 
+// TODO(tschmelcher): This stuff does not belong in this file.
 namespace glue {
 namespace _o3d {
 bool PluginObject::GetDisplayMode(int mode_id, o3d::DisplayMode *mode) {
   return renderer()->GetDisplayMode(mode_id, mode);
 }
 
 // TODO: Where should this really live?  It's platform-specific, but in
 // PluginObject, which mainly lives in cross/o3d_glue.h+cc.
 bool PluginObject::RequestFullscreenDisplay() {
   bool success = false;
@@ skipping 58 matching lines @@
     if (!renderer_->CancelFullscreen(display, prev_width_, prev_height_)) {
       LOG(FATAL) << "Failed to get the renderer out of fullscreen mode!";
     }
     ReplaceContentWindow(GetContentHWnd(), GetPluginHWnd(),
                          prev_width_, prev_height_);
     client()->SendResizeEvent(prev_width_, prev_height_, false);
   }
 }
 }  // namespace _o3d
 }  // namespace glue