Convert implicit scoped_refptr constructor calls to explicit ones, part 1

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/glue/plugins/plugin_host.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_piece.h"
@@ skipping 262 matching lines @@
 
   return !err;
 }
 
 }  // namespace NPAPI
 
 extern "C" {
 
 // Allocates memory from the host's memory space.
 void* NPN_MemAlloc(uint32_t size) {
-  scoped_refptr<NPAPI::PluginHost> host = NPAPI::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<NPAPI::PluginHost> host = NPAPI::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 reloadPages) {
   // TODO: implement me
   DVLOG(1) << "NPN_ReloadPlugin is not implemented yet.";
 }
 
 // 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<NPAPI::PluginInstance> plugin =
-      reinterpret_cast<NPAPI::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<NPAPI::PluginInstance> plugin = FindInstance(id);
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   if (!plugin.get()) {
     NOTREACHED();
     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
@@ skipping 44 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<NPAPI::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<NPAPI::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)
@@ skipping 41 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<NPAPI::PluginInstance> plugin = FindInstance(id);
+  scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
   DCHECK(plugin.get() != NULL);
   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;
@@ skipping 13 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<NPAPI::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<NPAPI::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<NPAPI::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 {
@@ skipping 33 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<NPAPI::PluginInstance> plugin = FindInstance(id);
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       *private_mode = plugin->webplugin()->IsOffTheRecord();
       rv = NPERR_NO_ERROR;
       break;
     }
     case default_plugin::kMissingPluginStatusStart +
          default_plugin::MISSING_PLUGIN_AVAILABLE:
     // fall through
     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<NPAPI::PluginInstance> plugin = FindInstance(id);
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       if (plugin->plugin_lib()->plugin_info().path.value() ==
             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<NPAPI::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 48 matching lines @@
     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<NPAPI::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 64 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<NPAPI::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<NPAPI::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<NPAPI::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<NPAPI::PluginInstance> plugin = FindInstance(id);
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       if (!plugin)
         return NPERR_GENERIC_ERROR;
 
       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)));
@@ skipping 19 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<NPAPI::PluginInstance> plugin = FindInstance(id);
+      scoped_refptr<NPAPI::PluginInstance> plugin(FindInstance(id));
       if (!plugin)
         return NPERR_GENERIC_ERROR;
 
       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);
@@ skipping 25 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<NPAPI::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<NPAPI::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<NPAPI::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<NPAPI::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;
 }
 
 }  // extern "C"