1// Copyright (c) 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#include "ppapi/proxy/file_system_resource.h"
6
7#include "base/bind.h"
8#include "base/stl_util.h"
9#include "ipc/ipc_message.h"
10#include "ppapi/c/pp_errors.h"
11#include "ppapi/proxy/ppapi_messages.h"
12#include "ppapi/shared_impl/file_growth.h"
13#include "ppapi/shared_impl/tracked_callback.h"
14#include "ppapi/thunk/enter.h"
15#include "ppapi/thunk/ppb_file_io_api.h"
16
17using ppapi::thunk::EnterResourceNoLock;
18using ppapi::thunk::PPB_FileIO_API;
19using ppapi::thunk::PPB_FileSystem_API;
20
21namespace ppapi {
22namespace proxy {
23
24FileSystemResource::QuotaRequest::QuotaRequest(
25    int64_t amount_arg,
26    const RequestQuotaCallback& callback_arg)
27    : amount(amount_arg),
28      callback(callback_arg) {
29}
30
31FileSystemResource::QuotaRequest::~QuotaRequest() {
32}
33
34FileSystemResource::FileSystemResource(Connection connection,
35                                       PP_Instance instance,
36                                       PP_FileSystemType type)
37    : PluginResource(connection, instance),
38      type_(type),
39      called_open_(false),
40      callback_count_(0),
41      callback_result_(PP_OK),
42      reserved_quota_(0),
43      reserving_quota_(false) {
44  DCHECK(type_ != PP_FILESYSTEMTYPE_INVALID);
45  SendCreate(RENDERER, PpapiHostMsg_FileSystem_Create(type_));
46  SendCreate(BROWSER, PpapiHostMsg_FileSystem_Create(type_));
47}
48
49FileSystemResource::FileSystemResource(Connection connection,
50                                       PP_Instance instance,
51                                       int pending_renderer_id,
52                                       int pending_browser_id,
53                                       PP_FileSystemType type)
54    : PluginResource(connection, instance),
55      type_(type),
56      called_open_(true),
57      callback_count_(0),
58      callback_result_(PP_OK),
59      reserved_quota_(0),
60      reserving_quota_(false) {
61  DCHECK(type_ != PP_FILESYSTEMTYPE_INVALID);
62  AttachToPendingHost(RENDERER, pending_renderer_id);
63  AttachToPendingHost(BROWSER, pending_browser_id);
64}
65
66FileSystemResource::~FileSystemResource() {
67}
68
69PPB_FileSystem_API* FileSystemResource::AsPPB_FileSystem_API() {
70  return this;
71}
72
73int32_t FileSystemResource::Open(int64_t expected_size,
74                                 scoped_refptr<TrackedCallback> callback) {
75  DCHECK(type_ != PP_FILESYSTEMTYPE_ISOLATED);
76  if (called_open_)
77    return PP_ERROR_FAILED;
78  called_open_ = true;
79
80  Call<PpapiPluginMsg_FileSystem_OpenReply>(RENDERER,
81      PpapiHostMsg_FileSystem_Open(expected_size),
82      base::Bind(&FileSystemResource::OpenComplete,
83                 this,
84                 callback));
85  Call<PpapiPluginMsg_FileSystem_OpenReply>(BROWSER,
86      PpapiHostMsg_FileSystem_Open(expected_size),
87      base::Bind(&FileSystemResource::OpenComplete,
88                 this,
89                 callback));
90  return PP_OK_COMPLETIONPENDING;
91}
92
93PP_FileSystemType FileSystemResource::GetType() {
94  return type_;
95}
96
97void FileSystemResource::OpenQuotaFile(PP_Resource file_io) {
98  DCHECK(!ContainsKey(files_, file_io));
99  files_.insert(file_io);
100}
101
102void FileSystemResource::CloseQuotaFile(PP_Resource file_io) {
103  DCHECK(ContainsKey(files_, file_io));
104  files_.erase(file_io);
105}
106
107int64_t FileSystemResource::RequestQuota(
108    int64_t amount,
109    const RequestQuotaCallback& callback) {
110  DCHECK(amount >= 0);
111  if (!reserving_quota_ && reserved_quota_ >= amount) {
112    reserved_quota_ -= amount;
113    return amount;
114  }
115
116  // Queue up a pending quota request.
117  pending_quota_requests_.push(QuotaRequest(amount, callback));
118
119  // Reserve more quota if we haven't already.
120  if (!reserving_quota_)
121    ReserveQuota(amount);
122
123  return PP_OK_COMPLETIONPENDING;
124}
125
126int32_t FileSystemResource::InitIsolatedFileSystem(
127    const std::string& fsid,
128    PP_IsolatedFileSystemType_Private type,
129    const base::Callback<void(int32_t)>& callback) {
130  // This call is mutually exclusive with Open() above, so we can reuse the
131  // called_open state.
132  DCHECK(type_ == PP_FILESYSTEMTYPE_ISOLATED);
133  if (called_open_)
134    return PP_ERROR_FAILED;
135  called_open_ = true;
136
137  Call<PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply>(RENDERER,
138      PpapiHostMsg_FileSystem_InitIsolatedFileSystem(fsid, type),
139      base::Bind(&FileSystemResource::InitIsolatedFileSystemComplete,
140      this,
141      callback));
142  Call<PpapiPluginMsg_FileSystem_InitIsolatedFileSystemReply>(BROWSER,
143      PpapiHostMsg_FileSystem_InitIsolatedFileSystem(fsid, type),
144      base::Bind(&FileSystemResource::InitIsolatedFileSystemComplete,
145      this,
146      callback));
147  return PP_OK_COMPLETIONPENDING;
148}
149
150void FileSystemResource::OpenComplete(
151    scoped_refptr<TrackedCallback> callback,
152    const ResourceMessageReplyParams& params) {
153  ++callback_count_;
154  // Prioritize worse result since only one status can be returned.
155  if (params.result() != PP_OK)
156    callback_result_ = params.result();
157  // Received callback from browser and renderer.
158  if (callback_count_ == 2)
159    callback->Run(callback_result_);
160}
161
162void FileSystemResource::InitIsolatedFileSystemComplete(
163    const base::Callback<void(int32_t)>& callback,
164    const ResourceMessageReplyParams& params) {
165  ++callback_count_;
166  // Prioritize worse result since only one status can be returned.
167  if (params.result() != PP_OK)
168    callback_result_ = params.result();
169  // Received callback from browser and renderer.
170  if (callback_count_ == 2)
171    callback.Run(callback_result_);
172}
173
174void FileSystemResource::ReserveQuota(int64_t amount) {
175  DCHECK(!reserving_quota_);
176  reserving_quota_ = true;
177
178  FileGrowthMap file_growths;
179  for (std::set<PP_Resource>::iterator it = files_.begin();
180       it != files_.end(); ++it) {
181    EnterResourceNoLock<PPB_FileIO_API> enter(*it, true);
182    if (enter.failed()) {
183      NOTREACHED();
184      continue;
185    }
186    PPB_FileIO_API* file_io_api = enter.object();
187    file_growths[*it] = FileGrowth(
188        file_io_api->GetMaxWrittenOffset(),
189        file_io_api->GetAppendModeWriteAmount());
190  }
191  Call<PpapiPluginMsg_FileSystem_ReserveQuotaReply>(BROWSER,
192      PpapiHostMsg_FileSystem_ReserveQuota(amount, file_growths),
193      base::Bind(&FileSystemResource::ReserveQuotaComplete,
194                 this));
195}
196
197void FileSystemResource::ReserveQuotaComplete(
198    const ResourceMessageReplyParams& params,
199    int64_t amount,
200    const FileSizeMap& file_sizes) {
201  DCHECK(reserving_quota_);
202  reserving_quota_ = false;
203  reserved_quota_ = amount;
204
205  for (FileSizeMap::const_iterator it = file_sizes.begin();
206       it != file_sizes.end(); ++it) {
207    EnterResourceNoLock<PPB_FileIO_API> enter(it->first, true);
208
209    // It is possible that the host has sent an offset for a file that has been
210    // destroyed in the plugin. Ignore it.
211    if (enter.failed())
212      continue;
213    PPB_FileIO_API* file_io_api = enter.object();
214    file_io_api->SetMaxWrittenOffset(it->second);
215    file_io_api->SetAppendModeWriteAmount(0);
216  }
217
218  DCHECK(!pending_quota_requests_.empty());
219  // If we can't grant the first request after refreshing reserved_quota_, then
220  // fail all pending quota requests to avoid an infinite refresh/fail loop.
221  bool fail_all = reserved_quota_ < pending_quota_requests_.front().amount;
222  while (!pending_quota_requests_.empty()) {
223    QuotaRequest& request = pending_quota_requests_.front();
224    if (fail_all) {
225      request.callback.Run(0);
226      pending_quota_requests_.pop();
227    } else if (reserved_quota_ >= request.amount) {
228      reserved_quota_ -= request.amount;
229      request.callback.Run(request.amount);
230      pending_quota_requests_.pop();
231    } else {
232      // Refresh the quota reservation for the first pending request that we
233      // can't satisfy.
234      ReserveQuota(request.amount);
235      break;
236    }
237  }
238}
239
240}  // namespace proxy
241}  // namespace ppapi
242