media/cdm/ppapi/cdm_file_io_impl.h

   1 // Copyright 2013 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 MEDIA_CDM_PPAPI_CDM_FILE_IO_IMPL_H_
   6 #define MEDIA_CDM_PPAPI_CDM_FILE_IO_IMPL_H_
   7
   8 #include <algorithm>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "media/cdm/ppapi/api/content_decryption_module.h"
  14 #include "ppapi/c/ppb_file_io.h"
  15 #include "ppapi/cpp/file_io.h"
  16 #include "ppapi/cpp/file_ref.h"
  17 #include "ppapi/cpp/instance.h"
  18 #include "ppapi/cpp/module.h"
  19 #include "ppapi/cpp/private/isolated_file_system_private.h"
  20 #include "ppapi/utility/completion_callback_factory.h"
  21
  22 namespace media {
  23
  24 // Due to PPAPI limitations, all functions must be called on the main thread.
  25 class CdmFileIOImpl : public cdm::FileIO {
  26  public:
  27   // A class that helps release |file_lock_map_|.
  28   // There should be only one instance of ResourceTracker in a process. Also,
  29   // ResourceTracker should outlive all CdmFileIOImpl instances.
  30   class ResourceTracker {
  31    public:
  32     ResourceTracker();
  33     ~ResourceTracker();
  34    private:
  35     DISALLOW_COPY_AND_ASSIGN(ResourceTracker);
  36   };
  37
  38   CdmFileIOImpl(cdm::FileIOClient* client, PP_Instance pp_instance);
  39
  40   // cdm::FileIO implementation.
  41   virtual void Open(const char* file_name, uint32_t file_name_size) OVERRIDE;
  42   virtual void Read() OVERRIDE;
  43   virtual void Write(const uint8_t* data, uint32_t data_size) OVERRIDE;
  44   virtual void Close() OVERRIDE;
  45
  46  private:
  47   enum State {
  48     FILE_UNOPENED,
  49     OPENING_FILE_SYSTEM,
  50     OPENING_FILE,
  51     FILE_OPENED,
  52     READING_FILE,
  53     WRITING_FILE,
  54     FILE_CLOSED
  55   };
  56
  57   enum ErrorType {
  58     OPEN_WHILE_IN_USE,
  59     READ_WHILE_IN_USE,
  60     WRITE_WHILE_IN_USE,
  61     OPEN_ERROR,
  62     READ_ERROR,
  63     WRITE_ERROR
  64   };
  65
  66   // Always use Close() to release |this| object.
  67   virtual ~CdmFileIOImpl();
  68
  69   // |file_id_| -> |is_file_lock_acquired_| map.
  70   // Design detail:
  71   // - We never erase an entry from this map.
  72   // - Pros: When the same file is read or written repeatedly, we don't need to
  73   //   insert/erase the entry repeatedly, which is expensive.
  74   // - Cons: If there are a lot of one-off files used, this map will be
  75   //   unnecessarily large. But this should be a rare case.
  76   // - Ideally we could use unordered_map for this. But unordered_set is only
  77   //   available in C++11.
  78   typedef std::map<std::string, bool> FileLockMap;
  79
  80   // File lock map shared by all CdmFileIOImpl objects to prevent read/write
  81   // race. A CdmFileIOImpl object tries to acquire a lock before opening a
  82   // file. If the file open failed, the lock is released. Otherwise, the
  83   // CdmFileIOImpl object holds the lock until Close() is called.
  84   // TODO(xhwang): Investigate the following cases and make sure we are good:
  85   // - This assumes all CDM instances run in the same process for a given file
  86   //   system.
  87   // - When multiple CDM instances are running in different profiles (e.g.
  88   //   normal/incognito window, multiple profiles), we may be overlocking.
  89   static FileLockMap* file_lock_map_;
  90
  91   // Sets |file_id_|. Returns false if |file_id_| cannot be set (e.g. origin URL
  92   // cannot be fetched).
  93   bool SetFileID();
  94
  95   // Acquires the file lock. Returns true if the lock is successfully acquired.
  96   // After the lock is acquired, other cdm::FileIO objects in the same process
  97   // and in the same origin will get kInUse when trying to open the same file.
  98   bool AcquireFileLock();
  99
 100   // Releases the file lock so that the file can be opened by other cdm::FileIO
 101   // objects.
 102   void ReleaseFileLock();
 103
 104   void OpenFileSystem();
 105   void OnFileSystemOpened(int32_t result, pp::FileSystem file_system);
 106   void OpenFile();
 107   void OnFileOpened(int32_t result);
 108   void ReadFile();
 109   void OnFileRead(int32_t bytes_read);
 110   void SetLength(uint32_t length);
 111   void OnLengthSet(int32_t result);
 112   void WriteFile();
 113   void OnFileWritten(int32_t bytes_written);
 114
 115   void CloseFile();
 116
 117   // Calls client_->OnXxxxComplete with kError asynchronously. In some cases we
 118   // could actually call them synchronously, but since these errors shouldn't
 119   // happen in normal cases, we are not optimizing such cases.
 120   void OnError(ErrorType error_type);
 121
 122   // Callback to notify client of error asynchronously.
 123   void NotifyClientOfError(int32_t result, ErrorType error_type);
 124
 125   State state_;
 126
 127   // Non-owning pointer.
 128   cdm::FileIOClient* const client_;
 129
 130   const pp::InstanceHandle pp_instance_handle_;
 131
 132   std::string file_name_;
 133
 134   // A string ID that uniquely identifies a file in the user's profile.
 135   // It consists of the origin of the document URL (including scheme, host and
 136   // port, delimited by colons) and the |file_name_|.
 137   // For example: http:example.com:8080/foo_file.txt
 138   std::string file_id_;
 139
 140   pp::IsolatedFileSystemPrivate isolated_file_system_;
 141   pp::FileSystem file_system_;
 142   pp::FileIO file_io_;
 143   pp::FileRef file_ref_;
 144
 145   pp::CompletionCallbackFactory<CdmFileIOImpl> callback_factory_;
 146
 147   // A temporary buffer to hold (partial) data to write or the data that has
 148   // been read. The size of |io_buffer_| is always "bytes to write" or "bytes to
 149   // read". Use "char" instead of "unit8_t" because PPB_FileIO uses char* for
 150   // binary data read and write.
 151   std::vector<char> io_buffer_;
 152
 153   // Offset into the file for reading/writing data. When writing data to the
 154   // file, this is also the offset to the |io_buffer_|.
 155   size_t io_offset_;
 156
 157   // Buffer to hold all read data requested. This buffer is passed to |client_|
 158   // when read completes.
 159   std::vector<char> cumulative_read_buffer_;
 160
 161   DISALLOW_COPY_AND_ASSIGN(CdmFileIOImpl);
 162 };
 163
 164 }  // namespace media
 165
 166 #endif  // MEDIA_CDM_PPAPI_CDM_FILE_IO_IMPL_H_