Revert "Move the NPAPI files from webkit/glue/plugins to webkit/plugins/npapi"

webkit/glue/plugins/plugin_host.cc

 // Copyright (c) 2010 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 "webkit/plugins/npapi/plugin_host.h"
+#include "webkit/glue/plugins/plugin_host.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
+#if defined(OS_MACOSX)
+#include "base/sys_info.h"
+#endif
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
-#include "build/build_config.h"
 #include "net/base/net_util.h"
 #include "third_party/npapi/bindings/npapi_extensions.h"
 #include "third_party/npapi/bindings/npruntime.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebBindings.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebKit.h"
 #include "webkit/glue/webkit_glue.h"
-#include "webkit/plugins/npapi/default_plugin_shared.h"
-#include "webkit/plugins/npapi/npapi_extension_thunk.h"
-#include "webkit/plugins/npapi/plugin_instance.h"
-#include "webkit/plugins/npapi/plugin_lib.h"
-#include "webkit/plugins/npapi/plugin_list.h"
-#include "webkit/plugins/npapi/plugin_stream_url.h"
-#include "webkit/plugins/npapi/webplugin_delegate.h"
-#include "webkit/plugins/npapi/webplugininfo.h"
-
-#if defined(OS_MACOSX)
-#include "base/sys_info.h"
-#endif
+#include "webkit/glue/plugins/default_plugin_shared.h"
+#include "webkit/glue/plugins/npapi_extension_thunk.h"
+#include "webkit/glue/plugins/plugin_instance.h"
+#include "webkit/glue/plugins/plugin_lib.h"
+#include "webkit/glue/plugins/plugin_list.h"
+#include "webkit/glue/plugins/plugin_stream_url.h"
+#include "webkit/glue/plugins/webplugin_delegate.h"
+#include "webkit/glue/plugins/webplugininfo.h"
 
 using WebKit::WebBindings;
 
-namespace webkit {
-namespace npapi {
-
 // Finds a PluginInstance from an NPP.
 // The caller must take a reference if needed.
-static PluginInstance* FindInstance(NPP id) {
+static NPAPI::PluginInstance* FindInstance(NPP id) {
   if (id == NULL) {
     return NULL;
   }
-  return reinterpret_cast<PluginInstance*>(id->ndata);
+  return reinterpret_cast<NPAPI::PluginInstance*>(id->ndata);
 }
 
 #if defined(OS_MACOSX)
 // Returns true if the OS supports shared accelerated surfaces via IOSurface.
 // This is true on Snow Leopard and higher.
 static bool SupportsSharingAcceleratedSurfaces() {
   int32 major, minor, bugfix;
   base::SysInfo::OperatingSystemVersionNumbers(&major, &minor, &bugfix);
   return major > 10 || (major == 10 && minor > 5);
 }
 #endif
 
+namespace NPAPI {
+
 scoped_refptr<PluginHost> PluginHost::singleton_;
 
 PluginHost::PluginHost() {
   InitializeHostFuncs();
 }
 
 PluginHost::~PluginHost() {
 }
 
 PluginHost *PluginHost::Singleton() {
@@ skipping 205 matching lines @@
           break;
       }
     }
     state = newstate;
     ptr++;
   } while (!done);
 
   return !err;
 }
 
-}  // namespace npapi
-}  // namespace webkit
+}  // namespace NPAPI
 
 extern "C" {
 
-using webkit::npapi::FindInstance;
-using webkit::npapi::PluginHost;
-using webkit::npapi::PluginInstance;
-using webkit::npapi::WebPlugin;
-
 // Allocates memory from the host's memory space.
 void* NPN_MemAlloc(uint32_t size) {
-  scoped_refptr<PluginHost> host(PluginHost::Singleton());
+  scoped_refptr<NPAPI::PluginHost> host(NPAPI::PluginHost::Singleton());
   if (host != NULL) {
     // Note: We must use the same allocator/deallocator
     // that is used by the javascript library, as some of the
     // JS APIs will pass memory to the plugin which the plugin
     // will attempt to free.
     return malloc(size);
   }
   return NULL;
 }
 
 // Deallocates memory from the host's memory space
 void NPN_MemFree(void* ptr) {
-  scoped_refptr<PluginHost> host(PluginHost::Singleton());
+  scoped_refptr<NPAPI::PluginHost> host(NPAPI::PluginHost::Singleton());
   if (host != NULL) {
     if (ptr != NULL && ptr != reinterpret_cast<void*>(-1))
       free(ptr);
   }
 }
 
 // Requests that the host free a specified amount of memory.
 uint32_t NPN_MemFlush(uint32_t size) {
   // This is not relevant on Windows; MAC specific
   return size;
 }
 
 // This is for dynamic discovery of new plugins.
 // Should force a re-scan of the plugins directory to load new ones.
 void NPN_ReloadPlugins(NPBool reload_pages) {
   WebKit::resetPluginCache(reload_pages ? true : false);
 }
 
 // Requests a range of bytes for a seekable stream.
 NPError NPN_RequestRead(NPStream* stream, NPByteRange* range_list) {
   if (!stream || !range_list)
     return NPERR_GENERIC_ERROR;
 
-  scoped_refptr<PluginInstance> plugin(
-      reinterpret_cast<PluginInstance*>(stream->ndata));
+  scoped_refptr<NPAPI::PluginInstance> plugin(
+      reinterpret_cast<NPAPI::PluginInstance*>(stream->ndata));
   if (!plugin.get())
     return NPERR_GENERIC_ERROR;
 
   plugin->RequestRead(stream, range_list);
   return NPERR_NO_ERROR;
 }
 
 // Generic form of GetURL for common code between GetURL and GetURLNotify.
 static NPError GetURLNotify(NPP id,
                             const char* url,
                             const char* target,
                             bool notify,
                             void* notify_data) {
   if (!url)
     return NPERR_INVALID_URL;
 
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (!plugin.get()) {
     return NPERR_GENERIC_ERROR;
   }
 
   plugin->RequestURL(url, "GET", target, NULL, 0, notify, notify_data);
   return NPERR_NO_ERROR;
 }
 
 // Requests creation of a new stream with the contents of the
 // specified URL; gets notification of the result.
@@ skipping 43 matching lines @@
                              const char* url,
                              const char* target,
                              uint32_t len,
                              const char* buf,
                              NPBool file,
                              bool notify,
                              void* notify_data) {
   if (!url)
     return NPERR_INVALID_URL;
 
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (!plugin.get()) {
     NOTREACHED();
     return NPERR_GENERIC_ERROR;
   }
 
   std::string post_file_contents;
 
   if (file) {
     // Post data to be uploaded from a file. This can be handled in two
     // ways.
@@ skipping 126 matching lines @@
 NPError NPN_DestroyStream(NPP id, NPStream* stream, NPReason reason) {
   // Destroys a stream (could be created by plugin or browser).
   //
   // Reasons:
   //    NPRES_DONE          - normal completion
   //    NPRES_USER_BREAK    - user terminated
   //    NPRES_NETWORK_ERROR - network error (all errors fit here?)
   //
   //
 
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin.get() == NULL) {
     NOTREACHED();
     return NPERR_GENERIC_ERROR;
   }
 
   return plugin->NPP_DestroyStream(stream, reason);
 }
 
 const char* NPN_UserAgent(NPP id) {
 #if defined(OS_WIN)
   // Flash passes in a null id during the NP_initialize call.  We need to
   // default to the Mozilla user agent if we don't have an NPP instance or
   // else Flash won't request windowless mode.
   bool use_mozilla_user_agent = true;
   if (id) {
-    scoped_refptr<PluginInstance> plugin = FindInstance(id);
+    scoped_refptr<NPAPI::PluginInstance> plugin = FindInstance(id);
     if (plugin.get() && !plugin->use_mozilla_user_agent())
       use_mozilla_user_agent = false;
   }
 
   if (use_mozilla_user_agent)
     return "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9a1) "
         "Gecko/20061103 Firefox/2.0a1";
 #elif defined(OS_MACOSX)
   // Silverlight 4 doesn't handle events correctly unless we claim to be Safari.
-  scoped_refptr<PluginInstance> plugin;
+  scoped_refptr<NPAPI::PluginInstance> plugin;
   if (id)
     plugin = FindInstance(id);
   if (plugin.get()) {
-    webkit::npapi::WebPluginInfo plugin_info =
-        plugin->plugin_lib()->plugin_info();
+    WebPluginInfo plugin_info = plugin->plugin_lib()->plugin_info();
     if (plugin_info.name == ASCIIToUTF16("Silverlight Plug-In") &&
         StartsWith(plugin_info.version, ASCIIToUTF16("4."), false)) {
       return "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_4; en-us) "
           "AppleWebKit/534.1+ (KHTML, like Gecko) Version/5.0 Safari/533.16";
     }
   }
 #endif
 
   return webkit_glue::GetUserAgent(GURL()).c_str();
 }
@@ skipping 11 matching lines @@
 
   // Before a windowless plugin can refresh part of its drawing area, it must
   // first invalidate it.  This function causes the NPP_HandleEvent method to
   // pass an update event or a paint message to the plug-in.  After calling
   // this method, the plug-in recieves a paint message asynchronously.
 
   // The browser redraws invalid areas of the document and any windowless
   // plug-ins at regularly timed intervals. To force a paint message, the
   // plug-in can call NPN_ForceRedraw after calling this method.
 
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin.get() && plugin->webplugin()) {
     if (invalidRect) {
 #if defined(OS_WIN)
       if (!plugin->windowless()) {
         RECT rect = {0};
         rect.left = invalidRect->left;
         rect.right = invalidRect->right;
         rect.top = invalidRect->top;
         rect.bottom = invalidRect->bottom;
         ::InvalidateRect(plugin->window_handle(), &rect, false);
@@ skipping 12 matching lines @@
 }
 
 void NPN_InvalidateRegion(NPP id, NPRegion invalidRegion) {
   // Invalidates a specified drawing region prior to repainting
   // or refreshing a window-less plugin.
   //
   // Similar to NPN_InvalidateRect.
 
   // TODO: this is overkill--add platform-specific region handling (at the
   // very least, fetch the region's bounding box and pass it to InvalidateRect).
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   DCHECK(plugin.get() != NULL);
   if (plugin.get() && plugin->webplugin())
     plugin->webplugin()->Invalidate();
 }
 
 void NPN_ForceRedraw(NPP id) {
   // Forces repaint for a windowless plug-in.
   //
   // We deliberately do not implement this; we don't want plugins forcing
   // synchronous paints.
 }
 
 NPError NPN_GetValue(NPP id, NPNVariable variable, void* value) {
   // Allows the plugin to query the browser for information
   //
   // Variables:
   //    NPNVxDisplay (unix only)
   //    NPNVxtAppContext (unix only)
   //    NPNVnetscapeWindow (win only) - Gets the native window on which the
   //              plug-in drawing occurs, returns HWND
   //    NPNVjavascriptEnabledBool:  tells whether Javascript is enabled
   //    NPNVasdEnabledBool:  tells whether SmartUpdate is enabled
   //    NPNVOfflineBool: tells whether offline-mode is enabled
 
   NPError rv = NPERR_GENERIC_ERROR;
 
   switch (static_cast<int>(variable)) {
     case NPNVWindowNPObject: {
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       NPObject *np_object = plugin->webplugin()->GetWindowScriptNPObject();
       // Return value is expected to be retained, as
       // described here:
       // <http://www.mozilla.org/projects/plugins/npruntime.html#browseraccess>
       if (np_object) {
         WebBindings::retainObject(np_object);
         void **v = (void **)value;
         *v = np_object;
         rv = NPERR_NO_ERROR;
       } else {
         NOTREACHED();
       }
       break;
     }
     case NPNVPluginElementNPObject: {
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       NPObject *np_object = plugin->webplugin()->GetPluginElement();
       // Return value is expected to be retained, as
       // described here:
       // <http://www.mozilla.org/projects/plugins/npruntime.html#browseraccess>
       if (np_object) {
         WebBindings::retainObject(np_object);
         void** v = static_cast<void**>(value);
         *v = np_object;
         rv = NPERR_NO_ERROR;
       } else {
         NOTREACHED();
       }
       break;
     }
   #if !defined(OS_MACOSX)  // OS X doesn't have windowed plugins.
     case NPNVnetscapeWindow: {
-      scoped_refptr<PluginInstance> plugin = FindInstance(id);
+      scoped_refptr<NPAPI::PluginInstance> plugin = FindInstance(id);
       if (!plugin.get()) {
         NOTREACHED();
         return NPERR_GENERIC_ERROR;
       }
       gfx::PluginWindowHandle handle = plugin->window_handle();
       *((void**)value) = (void*)handle;
       rv = NPERR_NO_ERROR;
       break;
     }
   #endif
@@ skipping 16 matching lines @@
       break;
   #endif
     case NPNVSupportsWindowless: {
       NPBool* supports_windowless = reinterpret_cast<NPBool*>(value);
       *supports_windowless = true;
       rv = NPERR_NO_ERROR;
       break;
     }
     case NPNVprivateModeBool: {
       NPBool* private_mode = reinterpret_cast<NPBool*>(value);
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       *private_mode = plugin->webplugin()->IsOffTheRecord();
       rv = NPERR_NO_ERROR;
       break;
     }
-    case webkit::npapi::default_plugin::kMissingPluginStatusStart +
-         webkit::npapi::default_plugin::MISSING_PLUGIN_AVAILABLE:
+    case default_plugin::kMissingPluginStatusStart +
+         default_plugin::MISSING_PLUGIN_AVAILABLE:
     // fall through
-    case webkit::npapi::default_plugin::kMissingPluginStatusStart +
-         webkit::npapi::default_plugin::MISSING_PLUGIN_USER_STARTED_DOWNLOAD: {
+    case default_plugin::kMissingPluginStatusStart +
+         default_plugin::MISSING_PLUGIN_USER_STARTED_DOWNLOAD: {
       // This is a hack for the default plugin to send notification to
       // renderer.  Even though we check if the plugin is the default plugin,
       // we still need to worry about future standard change that may conflict
       // with the variable definition, in order to avoid duplicate case clauses
       // in this big switch statement.
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       if (plugin->plugin_lib()->plugin_info().path.value() ==
-            webkit::npapi::kDefaultPluginLibraryName) {
-        plugin->webplugin()->OnMissingPluginStatus(variable -
-            webkit::npapi::default_plugin::kMissingPluginStatusStart);
+            kDefaultPluginLibraryName) {
+        plugin->webplugin()->OnMissingPluginStatus(
+            variable - default_plugin::kMissingPluginStatusStart);
       }
       break;
     }
   #if defined(OS_MACOSX)
     case NPNVpluginDrawingModel: {
       // return the drawing model that was negotiated when we initialized.
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       *reinterpret_cast<int*>(value) = plugin->drawing_model();
       rv = NPERR_NO_ERROR;
       break;
     }
 #ifndef NP_NO_QUICKDRAW
     case NPNVsupportsQuickDrawBool: {
       // We do not admit to supporting the QuickDraw drawing model. The logic
       // here is that our QuickDraw plugin support is so rudimentary that we
       // only want to use it as a fallback to keep plugins from crashing: if a
       // plugin knows enough to ask, we want them to use CoreGraphics.
@@ skipping 12 matching lines @@
       NPBool* supports_model = reinterpret_cast<NPBool*>(value);
       *supports_model = true;
       rv = NPERR_NO_ERROR;
       break;
     }
     case NPNVsupportsCoreAnimationBool: {
       // We only support the Core Animation model on 10.6 and higher
       // TODO(stuartmorgan): Once existing CA plugins have implemented the
       // invalidating version, remove support for this one.
       NPBool* supports_model = reinterpret_cast<NPBool*>(value);
-      *supports_model = webkit::npapi::SupportsSharingAcceleratedSurfaces() ?
-          true : false;
+      *supports_model = SupportsSharingAcceleratedSurfaces() ? true : false;
       rv = NPERR_NO_ERROR;
       break;
     }
     case NPNVsupportsInvalidatingCoreAnimationBool: {
       NPBool* supports_model = reinterpret_cast<NPBool*>(value);
       *supports_model = true;
       rv = NPERR_NO_ERROR;
       break;
     }
     case NPNVsupportsOpenGLBool: {
       // This drawing model was never widely supported, and we don't plan to
       // support it.
       NPBool* supports_model = reinterpret_cast<NPBool*>(value);
       *supports_model = false;
       rv = NPERR_NO_ERROR;
       break;
     }
   #endif  // OS_MACOSX
     case NPNVPepperExtensions:
       // Available for any plugin that attempts to get it.
       // If the plugin is not started in a Pepper implementation, it
       // will likely fail when it tries to use any of the functions
       // attached to the extension vector.
-      rv = webkit::npapi::GetPepperExtensionsFunctions(value);
+      rv = NPAPI::GetPepperExtensionsFunctions(value);
       break;
     default:
       DVLOG(1) << "NPN_GetValue(" << variable << ") is not implemented yet.";
       break;
   }
   return rv;
 }
 
 NPError NPN_SetValue(NPP id, NPPVariable variable, void* value) {
   // Allows the plugin to set various modes
 
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   switch(variable) {
     case NPPVpluginWindowBool: {
       // Sets windowless mode for display of the plugin
       // Note: the documentation at
       // http://developer.mozilla.org/en/docs/NPN_SetValue is wrong.  When
       // value is NULL, the mode is set to true.  This is the same way Mozilla
       // works.
       plugin->set_windowless(value == 0);
       return NPERR_NO_ERROR;
     }
@@ skipping 20 matching lines @@
       // TODO: implement me
       DVLOG(1) << "NPN_SetValue(NPPVpluginKeepLibraryInMemory) is not "
                   "implemented.";
       return NPERR_GENERIC_ERROR;
   #if defined(OS_MACOSX)
     case NPPVpluginDrawingModel: {
       int model = reinterpret_cast<int>(value);
       if (model == NPDrawingModelCoreGraphics ||
           model == NPDrawingModelInvalidatingCoreAnimation ||
           (model == NPDrawingModelCoreAnimation &&
-           webkit::npapi::SupportsSharingAcceleratedSurfaces())) {
+           SupportsSharingAcceleratedSurfaces())) {
         plugin->set_drawing_model(static_cast<NPDrawingModel>(model));
         return NPERR_NO_ERROR;
       }
       return NPERR_GENERIC_ERROR;
     }
     case NPPVpluginEventModel: {
       // we support Carbon and Cocoa event models
       int model = reinterpret_cast<int>(value);
       switch (model) {
 #ifndef NP_NO_CARBON
@@ skipping 23 matching lines @@
   return NULL;
 }
 
 void* NPN_GetJavaPeer(NPP) {
   // TODO: implement me
   DVLOG(1) << "NPN_GetJavaPeer is not implemented.";
   return NULL;
 }
 
 void NPN_PushPopupsEnabledState(NPP id, NPBool enabled) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin)
     plugin->PushPopupsEnabledState(enabled ? true : false);
 }
 
 void NPN_PopPopupsEnabledState(NPP id) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin)
     plugin->PopPopupsEnabledState();
 }
 
 void NPN_PluginThreadAsyncCall(NPP id,
                                void (*func)(void*),
                                void* user_data) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin)
     plugin->PluginThreadAsyncCall(func, user_data);
 }
 
 NPError NPN_GetValueForURL(NPP id,
                            NPNURLVariable variable,
                            const char* url,
                            char** value,
                            uint32_t* len) {
   if (!id)
     return NPERR_INVALID_PARAM;
 
   if (!url || !*url || !len)
     return NPERR_INVALID_URL;
 
   *len = 0;
   std::string result;
 
   switch (variable) {
     case NPNURLVProxy: {
       result = "DIRECT";
       if (!webkit_glue::FindProxyForUrl(GURL((std::string(url))), &result))
         return NPERR_GENERIC_ERROR;
 
       break;
     }
     case NPNURLVCookie: {
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       if (!plugin)
         return NPERR_GENERIC_ERROR;
 
-      WebPlugin* webplugin = plugin->webplugin();
+      webkit_glue::WebPlugin* webplugin = plugin->webplugin();
       if (!webplugin)
         return NPERR_GENERIC_ERROR;
 
       // Bypass third-party cookie blocking by using the url as the
       // first_party_for_cookies.
       GURL cookies_url((std::string(url)));
       result = webplugin->GetCookies(cookies_url, cookies_url);
       break;
     }
     default:
@@ skipping 15 matching lines @@
                            const char* value,
                            uint32_t len) {
   if (!id)
     return NPERR_INVALID_PARAM;
 
   if (!url || !*url)
     return NPERR_INVALID_URL;
 
   switch (variable) {
     case NPNURLVCookie: {
-      scoped_refptr<PluginInstance> plugin(FindInstance(id));
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       if (!plugin)
         return NPERR_GENERIC_ERROR;
 
-      WebPlugin* webplugin = plugin->webplugin();
+      webkit_glue::WebPlugin* webplugin = plugin->webplugin();
       if (!webplugin)
         return NPERR_GENERIC_ERROR;
 
       std::string cookie(value, len);
       GURL cookies_url((std::string(url)));
       webplugin->SetCookie(cookies_url, cookies_url, cookie);
       return NPERR_NO_ERROR;
     }
     case NPNURLVProxy:
       // We don't support setting proxy values, fall through...
@@ skipping 21 matching lines @@
     return NPERR_INVALID_PARAM;
 
   // TODO: implement me (bug 23928)
   return NPERR_GENERIC_ERROR;
 }
 
 uint32_t NPN_ScheduleTimer(NPP id,
                            uint32_t interval,
                            NPBool repeat,
                            void (*func)(NPP id, uint32_t timer_id)) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (!plugin)
     return 0;
 
   return plugin->ScheduleTimer(interval, repeat, func);
 }
 
 void NPN_UnscheduleTimer(NPP id, uint32_t timer_id) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin)
     plugin->UnscheduleTimer(timer_id);
 }
 
 NPError NPN_PopUpContextMenu(NPP id, NPMenu* menu) {
   if (!menu)
     return NPERR_INVALID_PARAM;
 
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin.get()) {
     return plugin->PopUpContextMenu(menu);
   }
   NOTREACHED();
   return NPERR_GENERIC_ERROR;
 }
 
 NPBool NPN_ConvertPoint(NPP id, double sourceX, double sourceY,
                         NPCoordinateSpace sourceSpace,
                         double *destX, double *destY,
                         NPCoordinateSpace destSpace) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(id));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (plugin.get()) {
     return plugin->ConvertPoint(sourceX, sourceY, sourceSpace,
                                 destX, destY, destSpace);
   }
   NOTREACHED();
   return false;
 }
 
 NPBool NPN_HandleEvent(NPP id, void *event, NPBool handled) {
   // TODO: Implement advanced key handling: http://crbug.com/46578
   NOTIMPLEMENTED();
   return false;
 }
 
 NPBool NPN_UnfocusInstance(NPP id, NPFocusDirection direction) {
   // TODO: Implement advanced key handling: http://crbug.com/46578
   NOTIMPLEMENTED();
   return false;
 }
 
 void NPN_URLRedirectResponse(NPP instance, void* notify_data, NPBool allow) {
-  scoped_refptr<PluginInstance> plugin(FindInstance(instance));
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(instance));
   if (plugin.get()) {
     plugin->URLRedirectResponse(!!allow, notify_data);
   }
 }
 
 }  // extern "C"