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 #ifndef CONTENT_CHILD_NPAPI_PLUGIN_STREAM_H_
      6 #define CONTENT_CHILD_NPAPI_PLUGIN_STREAM_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/files/file_path.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "build/build_config.h"
     14 #include "third_party/npapi/bindings/npapi.h"
     15 
     16 namespace content {
     17 
     18 class PluginInstance;
     19 class WebPluginResourceClient;
     20 
     21 // Base class for a NPAPI stream.  Tracks basic elements
     22 // of a stream for NPAPI notifications and stream position.
     23 class PluginStream : public base::RefCounted<PluginStream> {
     24  public:
     25   // Create a new PluginStream object.  If needNotify is true, then the
     26   // plugin will be notified when the stream has been fully sent.
     27   PluginStream(PluginInstance* instance,
     28                const char* url,
     29                bool need_notify,
     30                void* notify_data);
     31 
     32   // Opens the stream to the Plugin.
     33   // If the mime-type is not specified, we'll try to find one based on the
     34   // mime-types table and the extension (if any) in the URL.
     35   // If the size of the stream is known, use length to set the size.  If
     36   // not known, set length to 0.
     37   // The request_is_seekable parameter indicates whether byte range requests
     38   // can be issued on the stream.
     39   bool Open(const std::string &mime_type,
     40             const std::string &headers,
     41             uint32 length,
     42             uint32 last_modified,
     43             bool request_is_seekable);
     44 
     45   // Writes to the stream.
     46   int Write(const char* buf, const int len, int data_offset);
     47 
     48   // Write the result as a file.
     49   void WriteAsFile();
     50 
     51   // Notify the plugin that a stream is complete.
     52   void Notify(NPReason reason);
     53 
     54   // Close the stream.
     55   virtual bool Close(NPReason reason);
     56 
     57   virtual WebPluginResourceClient* AsResourceClient();
     58 
     59   // Cancels any HTTP requests initiated by the stream.
     60   virtual void CancelRequest() {}
     61 
     62   NPStream* stream() { return &stream_; }
     63 
     64   PluginInstance* instance() { return instance_.get(); }
     65 
     66   // setter/getter for the seekable attribute on the stream.
     67   bool seekable() const { return seekable_stream_; }
     68 
     69   void set_seekable(bool seekable) { seekable_stream_ = seekable; }
     70 
     71   // getters for reading the notification related attributes on the stream.
     72   bool notify_needed() const { return notify_needed_; }
     73 
     74   void* notify_data() const { return notify_data_; }
     75 
     76  protected:
     77   friend class base::RefCounted<PluginStream>;
     78 
     79   virtual ~PluginStream();
     80 
     81   // Check if the stream is open.
     82   bool open() { return opened_; }
     83 
     84  private:
     85   // Per platform method to reset the temporary file handle.
     86   void ResetTempFileHandle();
     87 
     88   // Per platform method to reset the temporary file name.
     89   void ResetTempFileName();
     90 
     91   // Open a temporary file for this stream.
     92   // If successful, will set temp_file_name_, temp_file_handle_, and
     93   // return true.
     94   bool OpenTempFile();
     95 
     96   // Closes the temporary file if it is open.
     97   void CloseTempFile();
     98 
     99   // Sends the data to the file. Called From WriteToFile.
    100   size_t WriteBytes(const char* buf, size_t length);
    101 
    102   // Sends the data to the file if it's open.
    103   bool WriteToFile(const char* buf, size_t length);
    104 
    105   // Sends the data to the plugin.  If it's not ready, handles buffering it
    106   // and retrying later.
    107   bool WriteToPlugin(const char* buf, const int length, const int data_offset);
    108 
    109   // Send the data to the plugin, returning how many bytes it accepted, or -1
    110   // if an error occurred.
    111   int TryWriteToPlugin(const char* buf, const int length,
    112                        const int data_offset);
    113 
    114   // The callback which calls TryWriteToPlugin.
    115   void OnDelayDelivery();
    116 
    117   // Returns true if the temp file is valid and open for writing.
    118   bool TempFileIsValid() const;
    119 
    120   // Returns true if |requested_plugin_mode_| is NP_ASFILE or NP_ASFILEONLY.
    121   bool RequestedPluginModeIsAsFile() const;
    122 
    123  private:
    124   NPStream                      stream_;
    125   std::string                   headers_;
    126   scoped_refptr<PluginInstance> instance_;
    127   bool                          notify_needed_;
    128   void*                         notify_data_;
    129   bool                          close_on_write_data_;
    130   uint16                        requested_plugin_mode_;
    131   bool                          opened_;
    132 #if defined(OS_WIN)
    133   char                          temp_file_name_[MAX_PATH];
    134   HANDLE                        temp_file_handle_;
    135 #elif defined(OS_POSIX)
    136   FILE*                         temp_file_;
    137   base::FilePath                temp_file_path_;
    138 #endif
    139   std::vector<char>             delivery_data_;
    140   int                           data_offset_;
    141   bool                          seekable_stream_;
    142   std::string                   mime_type_;
    143   DISALLOW_COPY_AND_ASSIGN(PluginStream);
    144 };
    145 
    146 }  // namespace content
    147 
    148 #endif  // CONTENT_CHILD_NPAPI_PLUGIN_STREAM_H_
    149