Home | History | Annotate | Download | only in npapi 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/child/npapi/plugin_instance.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/command_line.h"
      9 #include "base/files/file_util.h"
     10 #include "base/message_loop/message_loop.h"
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "build/build_config.h"
     14 #include "content/child/npapi/plugin_host.h"
     15 #include "content/child/npapi/plugin_lib.h"
     16 #include "content/child/npapi/plugin_stream_url.h"
     17 #include "content/child/npapi/plugin_string_stream.h"
     18 #include "content/child/npapi/webplugin.h"
     19 #include "content/child/npapi/webplugin_delegate.h"
     20 #include "content/child/npapi/webplugin_resource_client.h"
     21 #include "content/public/common/content_constants.h"
     22 #include "content/public/common/content_switches.h"
     23 #include "net/base/escape.h"
     24 
     25 #if defined(OS_MACOSX)
     26 #include <ApplicationServices/ApplicationServices.h>
     27 #endif
     28 
     29 namespace content {
     30 
     31 PluginInstance::PluginInstance(PluginLib* plugin, const std::string& mime_type)
     32     : plugin_(plugin),
     33       npp_(0),
     34       host_(PluginHost::Singleton()),
     35       npp_functions_(plugin->functions()),
     36       window_handle_(0),
     37       windowless_(false),
     38       transparent_(true),
     39       webplugin_(0),
     40       mime_type_(mime_type),
     41       get_notify_data_(0),
     42       use_mozilla_user_agent_(false),
     43 #if defined (OS_MACOSX)
     44 #ifdef NP_NO_QUICKDRAW
     45       drawing_model_(NPDrawingModelCoreGraphics),
     46 #else
     47       drawing_model_(NPDrawingModelQuickDraw),
     48 #endif
     49 #ifdef NP_NO_CARBON
     50       event_model_(NPEventModelCocoa),
     51 #else
     52       event_model_(NPEventModelCarbon),
     53 #endif
     54       currently_handled_event_(NULL),
     55 #endif
     56       message_loop_(base::MessageLoop::current()),
     57       load_manually_(false),
     58       in_close_streams_(false),
     59       next_timer_id_(1),
     60       next_notify_id_(0),
     61       next_range_request_id_(0),
     62       handles_url_redirects_(false) {
     63   npp_ = new NPP_t();
     64   npp_->ndata = 0;
     65   npp_->pdata = 0;
     66 
     67   if (mime_type_ == kFlashPluginSwfMimeType)
     68     transparent_ = false;
     69 
     70   memset(&zero_padding_, 0, sizeof(zero_padding_));
     71   DCHECK(message_loop_);
     72 }
     73 
     74 PluginInstance::~PluginInstance() {
     75   CloseStreams();
     76 
     77   if (npp_ != 0) {
     78     delete npp_;
     79     npp_ = 0;
     80   }
     81 
     82   if (plugin_.get())
     83     plugin_->CloseInstance();
     84 }
     85 
     86 PluginStreamUrl* PluginInstance::CreateStream(unsigned long resource_id,
     87                                               const GURL& url,
     88                                               const std::string& mime_type,
     89                                               int notify_id) {
     90 
     91   bool notify;
     92   void* notify_data;
     93   GetNotifyData(notify_id, &notify, &notify_data);
     94   PluginStreamUrl* stream = new PluginStreamUrl(
     95       resource_id, url, this, notify, notify_data);
     96 
     97   AddStream(stream);
     98   return stream;
     99 }
    100 
    101 void PluginInstance::AddStream(PluginStream* stream) {
    102   open_streams_.push_back(make_scoped_refptr(stream));
    103 }
    104 
    105 void PluginInstance::RemoveStream(PluginStream* stream) {
    106   if (in_close_streams_)
    107     return;
    108 
    109   std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
    110   for (stream_index = open_streams_.begin();
    111        stream_index != open_streams_.end(); ++stream_index) {
    112     if (stream_index->get() == stream) {
    113       open_streams_.erase(stream_index);
    114       break;
    115     }
    116   }
    117 }
    118 
    119 bool PluginInstance::IsValidStream(const NPStream* stream) {
    120   std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
    121   for (stream_index = open_streams_.begin();
    122           stream_index != open_streams_.end(); ++stream_index) {
    123     if ((*stream_index)->stream() == stream)
    124       return true;
    125   }
    126 
    127   return false;
    128 }
    129 
    130 void PluginInstance::CloseStreams() {
    131   in_close_streams_ = true;
    132   for (unsigned int index = 0; index < open_streams_.size(); ++index) {
    133     // Close all streams on the way down.
    134     open_streams_[index]->Close(NPRES_USER_BREAK);
    135   }
    136   open_streams_.clear();
    137   in_close_streams_ = false;
    138 }
    139 
    140 WebPluginResourceClient* PluginInstance::GetRangeRequest(
    141     int id) {
    142   PendingRangeRequestMap::iterator iter = pending_range_requests_.find(id);
    143   if (iter == pending_range_requests_.end()) {
    144     NOTREACHED();
    145     return NULL;
    146   }
    147 
    148   WebPluginResourceClient* rv = iter->second->AsResourceClient();
    149   pending_range_requests_.erase(iter);
    150   return rv;
    151 }
    152 
    153 bool PluginInstance::Start(const GURL& url,
    154                            char** const param_names,
    155                            char** const param_values,
    156                            int param_count,
    157                            bool load_manually) {
    158   load_manually_ = load_manually;
    159   unsigned short mode = load_manually_ ? NP_FULL : NP_EMBED;
    160   npp_->ndata = this;
    161 
    162   NPError err = NPP_New(mode, param_count,
    163       const_cast<char **>(param_names), const_cast<char **>(param_values));
    164 
    165   if (err == NPERR_NO_ERROR) {
    166     handles_url_redirects_ =
    167         ((npp_functions_->version >= NPVERS_HAS_URL_REDIRECT_HANDLING) &&
    168          (npp_functions_->urlredirectnotify));
    169   }
    170   return err == NPERR_NO_ERROR;
    171 }
    172 
    173 NPObject *PluginInstance::GetPluginScriptableObject() {
    174   NPObject *value = NULL;
    175   NPError error = NPP_GetValue(NPPVpluginScriptableNPObject, &value);
    176   if (error != NPERR_NO_ERROR || value == NULL)
    177     return NULL;
    178   return value;
    179 }
    180 
    181 bool PluginInstance::GetFormValue(base::string16* value) {
    182   // Plugins will allocate memory for the return value by using NPN_MemAlloc().
    183   char *plugin_value = NULL;
    184   NPError error = NPP_GetValue(NPPVformValue, &plugin_value);
    185   if (error != NPERR_NO_ERROR || !plugin_value) {
    186     return false;
    187   }
    188   // Assumes the result is UTF8 text, as Firefox does.
    189   *value = base::UTF8ToUTF16(plugin_value);
    190   host_->host_functions()->memfree(plugin_value);
    191   return true;
    192 }
    193 
    194 // WebPluginLoadDelegate methods
    195 void PluginInstance::DidFinishLoadWithReason(const GURL& url,
    196                                              NPReason reason,
    197                                              int notify_id) {
    198   bool notify;
    199   void* notify_data;
    200   GetNotifyData(notify_id, &notify, &notify_data);
    201   if (!notify) {
    202     NOTREACHED();
    203     return;
    204   }
    205 
    206   NPP_URLNotify(url.spec().c_str(), reason, notify_data);
    207 }
    208 
    209 unsigned PluginInstance::GetBackingTextureId() {
    210   // By default the plugin instance is not backed by an OpenGL texture.
    211   return 0;
    212 }
    213 
    214 // NPAPI methods
    215 NPError PluginInstance::NPP_New(unsigned short mode,
    216                                 short argc,
    217                                 char* argn[],
    218                                 char* argv[]) {
    219   DCHECK(npp_functions_ != 0);
    220   DCHECK(npp_functions_->newp != 0);
    221   DCHECK(argc >= 0);
    222 
    223   if (npp_functions_->newp != 0) {
    224     return npp_functions_->newp(
    225         (NPMIMEType)mime_type_.c_str(), npp_, mode,  argc, argn, argv, NULL);
    226   }
    227   return NPERR_INVALID_FUNCTABLE_ERROR;
    228 }
    229 
    230 void PluginInstance::NPP_Destroy() {
    231   DCHECK(npp_functions_ != 0);
    232   DCHECK(npp_functions_->destroy != 0);
    233 
    234   if (npp_functions_->destroy != 0) {
    235     NPSavedData *savedData = 0;
    236     npp_functions_->destroy(npp_, &savedData);
    237 
    238     // TODO: Support savedData.  Technically, these need to be
    239     //       saved on a per-URL basis, and then only passed
    240     //       to new instances of the plugin at the same URL.
    241     //       Sounds like a huge security risk.  When we do support
    242     //       these, we should pass them back to the PluginLib
    243     //       to be stored there.
    244     DCHECK(savedData == 0);
    245   }
    246 
    247   for (unsigned int file_index = 0; file_index < files_created_.size();
    248        file_index++) {
    249     base::DeleteFile(files_created_[file_index], false);
    250   }
    251 
    252   // Ensure that no timer callbacks are invoked after NPP_Destroy.
    253   timers_.clear();
    254 }
    255 
    256 NPError PluginInstance::NPP_SetWindow(NPWindow* window) {
    257   DCHECK(npp_functions_ != 0);
    258   DCHECK(npp_functions_->setwindow != 0);
    259 
    260   if (npp_functions_->setwindow != 0) {
    261     return npp_functions_->setwindow(npp_, window);
    262   }
    263   return NPERR_INVALID_FUNCTABLE_ERROR;
    264 }
    265 
    266 NPError PluginInstance::NPP_NewStream(NPMIMEType type,
    267                                       NPStream* stream,
    268                                       NPBool seekable,
    269                                       unsigned short* stype) {
    270   DCHECK(npp_functions_ != 0);
    271   DCHECK(npp_functions_->newstream != 0);
    272   if (npp_functions_->newstream != 0) {
    273       return npp_functions_->newstream(npp_, type, stream, seekable, stype);
    274   }
    275   return NPERR_INVALID_FUNCTABLE_ERROR;
    276 }
    277 
    278 NPError PluginInstance::NPP_DestroyStream(NPStream* stream, NPReason reason) {
    279   DCHECK(npp_functions_ != 0);
    280   DCHECK(npp_functions_->destroystream != 0);
    281 
    282   if (stream == NULL || !IsValidStream(stream) || (stream->ndata == NULL))
    283     return NPERR_INVALID_INSTANCE_ERROR;
    284 
    285   if (npp_functions_->destroystream != 0) {
    286     NPError result = npp_functions_->destroystream(npp_, stream, reason);
    287     stream->ndata = NULL;
    288     return result;
    289   }
    290   return NPERR_INVALID_FUNCTABLE_ERROR;
    291 }
    292 
    293 int PluginInstance::NPP_WriteReady(NPStream* stream) {
    294   DCHECK(npp_functions_ != 0);
    295   DCHECK(npp_functions_->writeready != 0);
    296   if (npp_functions_->writeready != 0) {
    297     return npp_functions_->writeready(npp_, stream);
    298   }
    299   return 0;
    300 }
    301 
    302 int PluginInstance::NPP_Write(NPStream* stream,
    303                               int offset,
    304                               int len,
    305                               void* buffer) {
    306   DCHECK(npp_functions_ != 0);
    307   DCHECK(npp_functions_->write != 0);
    308   if (npp_functions_->write != 0) {
    309     return npp_functions_->write(npp_, stream, offset, len, buffer);
    310   }
    311   return 0;
    312 }
    313 
    314 void PluginInstance::NPP_StreamAsFile(NPStream* stream, const char* fname) {
    315   DCHECK(npp_functions_ != 0);
    316   DCHECK(npp_functions_->asfile != 0);
    317   if (npp_functions_->asfile != 0) {
    318     npp_functions_->asfile(npp_, stream, fname);
    319   }
    320 
    321   // Creating a temporary FilePath instance on the stack as the explicit
    322   // FilePath constructor with StringType as an argument causes a compiler
    323   // error when invoked via vector push back.
    324   base::FilePath file_name = base::FilePath::FromUTF8Unsafe(fname);
    325   files_created_.push_back(file_name);
    326 }
    327 
    328 void PluginInstance::NPP_URLNotify(const char* url,
    329                                    NPReason reason,
    330                                    void* notifyData) {
    331   DCHECK(npp_functions_ != 0);
    332   DCHECK(npp_functions_->urlnotify != 0);
    333   if (npp_functions_->urlnotify != 0) {
    334     npp_functions_->urlnotify(npp_, url, reason, notifyData);
    335   }
    336 }
    337 
    338 NPError PluginInstance::NPP_GetValue(NPPVariable variable, void* value) {
    339   DCHECK(npp_functions_ != 0);
    340   // getvalue is NULL for Shockwave
    341   if (npp_functions_->getvalue != 0) {
    342     return npp_functions_->getvalue(npp_, variable, value);
    343   }
    344   return NPERR_INVALID_FUNCTABLE_ERROR;
    345 }
    346 
    347 NPError PluginInstance::NPP_SetValue(NPNVariable variable, void* value) {
    348   DCHECK(npp_functions_ != 0);
    349   if (npp_functions_->setvalue != 0) {
    350     return npp_functions_->setvalue(npp_, variable, value);
    351   }
    352   return NPERR_INVALID_FUNCTABLE_ERROR;
    353 }
    354 
    355 short PluginInstance::NPP_HandleEvent(void* event) {
    356   DCHECK(npp_functions_ != 0);
    357   DCHECK(npp_functions_->event != 0);
    358   if (npp_functions_->event != 0) {
    359     return npp_functions_->event(npp_, (void*)event);
    360   }
    361   return false;
    362 }
    363 
    364 bool PluginInstance::NPP_Print(NPPrint* platform_print) {
    365   DCHECK(npp_functions_ != 0);
    366   if (npp_functions_->print != 0) {
    367     npp_functions_->print(npp_, platform_print);
    368     return true;
    369   }
    370   return false;
    371 }
    372 
    373 void PluginInstance::NPP_URLRedirectNotify(const char* url, int32_t status,
    374                                            void* notify_data) {
    375   DCHECK(npp_functions_ != 0);
    376   if (npp_functions_->urlredirectnotify != 0) {
    377     npp_functions_->urlredirectnotify(npp_, url, status, notify_data);
    378   }
    379 }
    380 
    381 void PluginInstance::SendJavaScriptStream(const GURL& url,
    382                                           const std::string& result,
    383                                           bool success,
    384                                           int notify_id) {
    385   bool notify;
    386   void* notify_data;
    387   GetNotifyData(notify_id, &notify, &notify_data);
    388 
    389   if (success) {
    390     PluginStringStream *stream =
    391         new PluginStringStream(this, url, notify, notify_data);
    392     AddStream(stream);
    393     stream->SendToPlugin(result, "text/html");
    394   } else {
    395     // NOTE: Sending an empty stream here will crash MacroMedia
    396     // Flash 9.  Just send the URL Notify.
    397     if (notify)
    398       NPP_URLNotify(url.spec().c_str(), NPRES_DONE, notify_data);
    399   }
    400 }
    401 
    402 void PluginInstance::DidReceiveManualResponse(const GURL& url,
    403                                               const std::string& mime_type,
    404                                               const std::string& headers,
    405                                               uint32 expected_length,
    406                                               uint32 last_modified) {
    407   DCHECK(load_manually_);
    408 
    409   plugin_data_stream_ =
    410       CreateStream(static_cast<unsigned long>(-1), url, mime_type, 0);
    411   plugin_data_stream_->DidReceiveResponse(mime_type, headers, expected_length,
    412                                           last_modified, true);
    413 }
    414 
    415 void PluginInstance::DidReceiveManualData(const char* buffer, int length) {
    416   DCHECK(load_manually_);
    417   if (plugin_data_stream_.get() != NULL) {
    418     plugin_data_stream_->DidReceiveData(buffer, length, 0);
    419   }
    420 }
    421 
    422 void PluginInstance::DidFinishManualLoading() {
    423   DCHECK(load_manually_);
    424   if (plugin_data_stream_.get() != NULL) {
    425     plugin_data_stream_->DidFinishLoading(plugin_data_stream_->ResourceId());
    426     plugin_data_stream_->Close(NPRES_DONE);
    427     plugin_data_stream_ = NULL;
    428   }
    429 }
    430 
    431 void PluginInstance::DidManualLoadFail() {
    432   DCHECK(load_manually_);
    433   if (plugin_data_stream_.get() != NULL) {
    434     plugin_data_stream_->DidFail(plugin_data_stream_->ResourceId());
    435     plugin_data_stream_ = NULL;
    436   }
    437 }
    438 
    439 void PluginInstance::PluginThreadAsyncCall(void (*func)(void*),
    440                                            void* user_data) {
    441   message_loop_->PostTask(
    442       FROM_HERE, base::Bind(&PluginInstance::OnPluginThreadAsyncCall, this,
    443                             func, user_data));
    444 }
    445 
    446 void PluginInstance::OnPluginThreadAsyncCall(void (*func)(void*),
    447                                              void* user_data) {
    448   // Do not invoke the callback if NPP_Destroy has already been invoked.
    449   if (webplugin_)
    450     func(user_data);
    451 }
    452 
    453 uint32 PluginInstance::ScheduleTimer(uint32 interval,
    454                                      NPBool repeat,
    455                                      void (*func)(NPP id, uint32 timer_id)) {
    456   // Use next timer id.
    457   uint32 timer_id;
    458   timer_id = next_timer_id_;
    459   ++next_timer_id_;
    460   DCHECK(next_timer_id_ != 0);
    461 
    462   // Record timer interval and repeat.
    463   TimerInfo info;
    464   info.interval = interval;
    465   info.repeat = repeat ? true : false;
    466   timers_[timer_id] = info;
    467 
    468   // Schedule the callback.
    469   base::MessageLoop::current()->PostDelayedTask(
    470       FROM_HERE,
    471       base::Bind(&PluginInstance::OnTimerCall, this, func, npp_, timer_id),
    472       base::TimeDelta::FromMilliseconds(interval));
    473   return timer_id;
    474 }
    475 
    476 void PluginInstance::UnscheduleTimer(uint32 timer_id) {
    477   // Remove info about the timer.
    478   TimerMap::iterator it = timers_.find(timer_id);
    479   if (it != timers_.end())
    480     timers_.erase(it);
    481 }
    482 
    483 #if !defined(OS_MACOSX)
    484 NPError PluginInstance::PopUpContextMenu(NPMenu* menu) {
    485   NOTIMPLEMENTED();
    486   return NPERR_GENERIC_ERROR;
    487 }
    488 #endif
    489 
    490 void PluginInstance::OnTimerCall(void (*func)(NPP id, uint32 timer_id),
    491                                  NPP id,
    492                                  uint32 timer_id) {
    493   // Do not invoke callback if the timer has been unscheduled.
    494   TimerMap::iterator it = timers_.find(timer_id);
    495   if (it == timers_.end())
    496     return;
    497 
    498   // Get all information about the timer before invoking the callback. The
    499   // callback might unschedule the timer.
    500   TimerInfo info = it->second;
    501 
    502   func(id, timer_id);
    503 
    504   // If the timer was unscheduled by the callback, just free up the timer id.
    505   if (timers_.find(timer_id) == timers_.end())
    506     return;
    507 
    508   // Reschedule repeating timers after invoking the callback so callback is not
    509   // re-entered if it pumps the message loop.
    510   if (info.repeat) {
    511     base::MessageLoop::current()->PostDelayedTask(
    512         FROM_HERE,
    513         base::Bind(&PluginInstance::OnTimerCall, this, func, npp_, timer_id),
    514         base::TimeDelta::FromMilliseconds(info.interval));
    515   } else {
    516     timers_.erase(it);
    517   }
    518 }
    519 
    520 void PluginInstance::PushPopupsEnabledState(bool enabled) {
    521   popups_enabled_stack_.push(enabled);
    522 }
    523 
    524 void PluginInstance::PopPopupsEnabledState() {
    525   popups_enabled_stack_.pop();
    526 }
    527 
    528 void PluginInstance::RequestRead(NPStream* stream, NPByteRange* range_list) {
    529   std::string range_info = "bytes=";
    530 
    531   while (range_list) {
    532     range_info += base::IntToString(range_list->offset);
    533     range_info.push_back('-');
    534     range_info +=
    535         base::IntToString(range_list->offset + range_list->length - 1);
    536     range_list = range_list->next;
    537     if (range_list)
    538       range_info.push_back(',');
    539   }
    540 
    541   if (plugin_data_stream_.get()) {
    542     if (plugin_data_stream_->stream() == stream) {
    543       webplugin_->CancelDocumentLoad();
    544       plugin_data_stream_ = NULL;
    545     }
    546   }
    547 
    548   // The lifetime of a NPStream instance depends on the PluginStream instance
    549   // which owns it. When a plugin invokes NPN_RequestRead on a seekable stream,
    550   // we don't want to create a new stream when the corresponding response is
    551   // received. We send over a cookie which represents the PluginStream
    552   // instance which is sent back from the renderer when the response is
    553   // received.
    554   std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
    555   for (stream_index = open_streams_.begin();
    556           stream_index != open_streams_.end(); ++stream_index) {
    557     PluginStream* plugin_stream = stream_index->get();
    558     if (plugin_stream->stream() == stream) {
    559       // A stream becomes seekable the first time NPN_RequestRead
    560       // is called on it.
    561       plugin_stream->set_seekable(true);
    562 
    563       if (CommandLine::ForCurrentProcess()->HasSwitch(
    564               switches::kDisableDirectNPAPIRequests)) {
    565         pending_range_requests_[++next_range_request_id_] = plugin_stream;
    566         webplugin_->InitiateHTTPRangeRequest(
    567             stream->url, range_info.c_str(), next_range_request_id_);
    568         return;
    569       } else {
    570         PluginStreamUrl* plugin_stream_url =
    571             static_cast<PluginStreamUrl*>(plugin_stream);
    572         plugin_stream_url->FetchRange(range_info);
    573         return;
    574       }
    575     }
    576   }
    577   NOTREACHED();
    578 }
    579 
    580 void PluginInstance::RequestURL(const char* url,
    581                                 const char* method,
    582                                 const char* target,
    583                                 const char* buf,
    584                                 unsigned int len,
    585                                 bool notify,
    586                                 void* notify_data) {
    587   int notify_id = 0;
    588   if (notify) {
    589     notify_id = ++next_notify_id_;
    590     pending_requests_[notify_id] = notify_data;
    591   }
    592 
    593   webplugin_->HandleURLRequest(
    594       url, method, target, buf, len, notify_id, popups_allowed(),
    595       notify ? handles_url_redirects_ : false);
    596 }
    597 
    598 bool PluginInstance::ConvertPoint(double source_x, double source_y,
    599                                   NPCoordinateSpace source_space,
    600                                   double* dest_x, double* dest_y,
    601                                   NPCoordinateSpace dest_space) {
    602 #if defined(OS_MACOSX)
    603   CGRect main_display_bounds = CGDisplayBounds(CGMainDisplayID());
    604 
    605   double flipped_screen_x = source_x;
    606   double flipped_screen_y = source_y;
    607   switch(source_space) {
    608     case NPCoordinateSpacePlugin:
    609       flipped_screen_x += plugin_origin_.x();
    610       flipped_screen_y += plugin_origin_.y();
    611       break;
    612     case NPCoordinateSpaceWindow:
    613       flipped_screen_x += containing_window_frame_.x();
    614       flipped_screen_y = containing_window_frame_.height() - source_y +
    615           containing_window_frame_.y();
    616       break;
    617     case NPCoordinateSpaceFlippedWindow:
    618       flipped_screen_x += containing_window_frame_.x();
    619       flipped_screen_y += containing_window_frame_.y();
    620       break;
    621     case NPCoordinateSpaceScreen:
    622       flipped_screen_y = main_display_bounds.size.height - flipped_screen_y;
    623       break;
    624     case NPCoordinateSpaceFlippedScreen:
    625       break;
    626     default:
    627       NOTREACHED();
    628       return false;
    629   }
    630 
    631   double target_x = flipped_screen_x;
    632   double target_y = flipped_screen_y;
    633   switch(dest_space) {
    634     case NPCoordinateSpacePlugin:
    635       target_x -= plugin_origin_.x();
    636       target_y -= plugin_origin_.y();
    637       break;
    638     case NPCoordinateSpaceWindow:
    639       target_x -= containing_window_frame_.x();
    640       target_y -= containing_window_frame_.y();
    641       target_y = containing_window_frame_.height() - target_y;
    642       break;
    643     case NPCoordinateSpaceFlippedWindow:
    644       target_x -= containing_window_frame_.x();
    645       target_y -= containing_window_frame_.y();
    646       break;
    647     case NPCoordinateSpaceScreen:
    648       target_y = main_display_bounds.size.height - flipped_screen_y;
    649       break;
    650     case NPCoordinateSpaceFlippedScreen:
    651       break;
    652     default:
    653       NOTREACHED();
    654       return false;
    655   }
    656 
    657   if (dest_x)
    658     *dest_x = target_x;
    659   if (dest_y)
    660     *dest_y = target_y;
    661   return true;
    662 #else
    663   NOTIMPLEMENTED();
    664   return false;
    665 #endif
    666 }
    667 
    668 void PluginInstance::GetNotifyData(int notify_id,
    669                                    bool* notify,
    670                                    void** notify_data) {
    671   PendingRequestMap::iterator iter = pending_requests_.find(notify_id);
    672   if (iter != pending_requests_.end()) {
    673     *notify = true;
    674     *notify_data = iter->second;
    675     pending_requests_.erase(iter);
    676   } else {
    677     *notify = false;
    678     *notify_data = NULL;
    679   }
    680 }
    681 
    682 void PluginInstance::URLRedirectResponse(bool allow, void* notify_data) {
    683   // The notify_data passed in allows us to identify the matching stream.
    684   std::vector<scoped_refptr<PluginStream> >::iterator stream_index;
    685   for (stream_index = open_streams_.begin();
    686           stream_index != open_streams_.end(); ++stream_index) {
    687     PluginStream* plugin_stream = stream_index->get();
    688     if (plugin_stream->notify_data() == notify_data) {
    689       PluginStreamUrl* plugin_stream_url =
    690           static_cast<PluginStreamUrl*>(plugin_stream);
    691       plugin_stream_url->URLRedirectResponse(allow);
    692       break;
    693     }
    694   }
    695 }
    696 
    697 }  // namespace content
    698