Implemented NPN_ScheduleTimer and NPN_UnscheduleTimer.

webkit/glue/plugins/plugin_instance.cc

 // Copyright (c) 2006-2008 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 "build/build_config.h"
 
 #include "webkit/glue/plugins/plugin_instance.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 20 matching lines @@
       transparent_(true),
       webplugin_(0),
       mime_type_(mime_type),
       use_mozilla_user_agent_(false),
 #if defined (OS_MACOSX)
       drawing_model_(0),
       event_model_(0),
 #endif
       message_loop_(MessageLoop::current()),
       load_manually_(false),
-      in_close_streams_(false) {
+      in_close_streams_(false),
+      next_timer_id_(1) {
   npp_ = new NPP_t();
   npp_->ndata = 0;
   npp_->pdata = 0;
 
   memset(&zero_padding_, 0, sizeof(zero_padding_));
   DCHECK(message_loop_);
 }
 
 PluginInstance::~PluginInstance() {
   CloseStreams();
@@ skipping 97 matching lines @@
 
   if (npp_functions_->newp != 0) {
     return npp_functions_->newp(
         (NPMIMEType)mime_type_.c_str(), npp_, mode,  argc, argn, argv, NULL);
   }
   return NPERR_INVALID_FUNCTABLE_ERROR;
 }
 
 void PluginInstance::NPP_Destroy() {
   DCHECK(npp_functions_ != 0);
-  DCHECK(npp_functions_->newp != 0);
+  DCHECK(npp_functions_->destroy != 0);
 
   if (npp_functions_->destroy != 0) {
     NPSavedData *savedData = 0;
     npp_functions_->destroy(npp_, &savedData);
 
     // TODO: Support savedData.  Technically, these need to be
     //       saved on a per-URL basis, and then only passed
     //       to new instances of the plugin at the same URL.
     //       Sounds like a huge security risk.  When we do support
     //       these, we should pass them back to the PluginLib
     //       to be stored there.
     DCHECK(savedData == 0);
   }
 
   for (unsigned int file_index = 0; file_index < files_created_.size();
        file_index++) {
     file_util::Delete(files_created_[file_index], false);
   }
+
+  // Ensure that no timer callbacks are invoked after NPP_Destroy.
+  timers_.clear();
 }
 
 NPError PluginInstance::NPP_SetWindow(NPWindow *window) {
   DCHECK(npp_functions_ != 0);
   DCHECK(npp_functions_->setwindow != 0);
 
   if (npp_functions_->setwindow != 0) {
     return npp_functions_->setwindow(npp_, window);
   }
   return NPERR_INVALID_FUNCTABLE_ERROR;
@@ skipping 166 matching lines @@
 }
 
 void PluginInstance::PluginThreadAsyncCall(void (*func)(void *),
                                            void *user_data) {
   message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
       this, &PluginInstance::OnPluginThreadAsyncCall, func, user_data));
 }
 
 void PluginInstance::OnPluginThreadAsyncCall(void (*func)(void *),
                                              void *user_data) {
-#if defined(OS_WIN)
-    // We are invoking an arbitrary callback provided by a third
-  // party plugin. It's better to wrap this into an exception
-  // block to protect us from crashes.
-  __try {
-    func(user_data);
-  } __except(EXCEPTION_EXECUTE_HANDLER) {
-    // Maybe we can disable a crashing plugin.
-    // But for now, just continue.
+  func(user_data);
+}
+
+uint32 PluginInstance::ScheduleTimer(uint32 interval,
+                                     NPBool repeat,
+                                     void (*func)(NPP id, uint32 timer_id)) {
+  // Use next timer id.
+  uint32 timer_id;
+  timer_id = next_timer_id_;
+  ++next_timer_id_;
+  DCHECK(next_timer_id_ != 0);
+
+  // Record timer interval and repeat.
+  TimerInfo info;
+  info.interval = interval;
+  info.repeat = repeat;
+  timers_[timer_id] = info;
+
+  // Schedule the callback.
+  message_loop_->PostDelayedTask(FROM_HERE,
+                                 NewRunnableMethod(this,
+                                                   &PluginInstance::OnTimerCall,
+                                                   func,
+                                                   npp_,
+                                                   timer_id),
+                                 interval);
+  return timer_id;
+}
+
+void PluginInstance::UnscheduleTimer(uint32 timer_id) {
+  // Remove info about the timer.
+  TimerMap::iterator it = timers_.find(timer_id);
+  if (it != timers_.end())
+    timers_.erase(it);
+}
+
+void PluginInstance::OnTimerCall(void (*func)(NPP id, uint32 timer_id),
+                                 NPP id,
+                                 uint32 timer_id) {
+  // Do not invoke callback if the timer has been unscheduled.
+  TimerMap::iterator it = timers_.find(timer_id);
+  if (it == timers_.end())
+    return;
+
+  // Get all information about the timer before invoking the callback. The
+  // callback might unschedule the timer.
+  TimerInfo info = it->second;
+
+  func(id, timer_id);
+
+  // If the timer was unscheduled by the callback, just free up the timer id.
+  if (timers_.find(timer_id) == timers_.end())
+    return;
+
+  // Reschedule repeating timers after invoking the callback so callback is not
+  // re-entered if it pumps the messager loop.
+  if (info.repeat) {
+    message_loop_->PostDelayedTask(FROM_HERE,
+                                   NewRunnableMethod(
+                                       this,
+                                       &PluginInstance::OnTimerCall,
+                                       func,
+                                       npp_,
+                                       timer_id),
+                                   info.interval);
+  } else {
+    timers_.erase(it);
   }
-#else
-  func(user_data);
-#endif
 }
 
 void PluginInstance::PushPopupsEnabledState(bool enabled) {
   popups_enabled_stack_.push(enabled);
 }
 
 void PluginInstance::PopPopupsEnabledState() {
   popups_enabled_stack_.pop();
 }
 
@@ skipping 36 matching lines @@
           stream->url, range_info.c_str(),
           reinterpret_cast<intptr_t>(plugin_stream),
           plugin_stream->notify_needed(),
           reinterpret_cast<intptr_t>(plugin_stream->notify_data()));
       break;
     }
   }
 }
 
 }  // namespace NPAPI