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 <sstream>
6
7 #include "ppapi/c/ppb_file_io.h"
8 #include "ppapi/cpp/file_io.h"
9 #include "ppapi/cpp/file_ref.h"
10 #include "ppapi/cpp/instance.h"
11 #include "ppapi/cpp/module.h"
12 #include "ppapi/cpp/private/isolated_file_system_private.h"
13 #include "ppapi/utility/completion_callback_factory.h"
14
15 // When compiling natively on Windows, PostMessage can be #define-d to
16 // something else.
17 #ifdef PostMessage
18 #undef PostMessage
19 #endif
20
21 // Buffer size for reading file.
22 const size_t kBufSize = 1024;
23
24 class MyInstance : public pp::Instance {
25 public:
MyInstance(PP_Instance instance)26 explicit MyInstance(PP_Instance instance)
27 : pp::Instance(instance),
28 handle_(instance) {
29 factory_.Initialize(this);
30 }
~MyInstance()31 virtual ~MyInstance() {
32 }
33
34 // Handler for the page sending us messages.
35 virtual void HandleMessage(const pp::Var& message_data);
36
37 private:
38 void OpenCrxFsAndReadFile(const std::string& filename);
39
40 void CrxFileSystemCallback(int32_t pp_error, pp::FileSystem file_system);
41 void FileIOOpenCallback(int32_t pp_error);
42 void FileIOReadCallback(int32_t pp_error);
43
44 // Forwards the given string to the page.
45 void ReportResponse(const char* name, int32_t pp_error);
46
47 // Generates completion callbacks scoped to this class.
48 pp::CompletionCallbackFactory<MyInstance> factory_;
49
50 pp::InstanceHandle handle_;
51 pp::IsolatedFileSystemPrivate crxfs_;
52 pp::FileRef file_ref_;
53 pp::FileIO file_io_;
54 std::string filename_;
55 char read_buf_[kBufSize];
56 };
57
HandleMessage(const pp::Var & message_data)58 void MyInstance::HandleMessage(const pp::Var& message_data) {
59 if (!message_data.is_string()) {
60 ReportResponse("HandleMessage: not a string", 0);
61 return;
62 }
63 std::string filename = message_data.AsString();
64 OpenCrxFsAndReadFile(filename);
65 }
66
OpenCrxFsAndReadFile(const std::string & filename)67 void MyInstance::OpenCrxFsAndReadFile(const std::string& filename) {
68 filename_ = filename;
69
70 pp::CompletionCallbackWithOutput<pp::FileSystem> callback =
71 factory_.NewCallbackWithOutput(&MyInstance::CrxFileSystemCallback);
72
73 crxfs_ = pp::IsolatedFileSystemPrivate(
74 this, PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_CRX);
75 int32_t rv = crxfs_.Open(callback);
76 if (rv != PP_OK_COMPLETIONPENDING)
77 ReportResponse("ExtCrxFileSystemPrivate::Open", rv);
78 }
79
CrxFileSystemCallback(int32_t pp_error,pp::FileSystem file_system)80 void MyInstance::CrxFileSystemCallback(int32_t pp_error,
81 pp::FileSystem file_system) {
82 if (pp_error != PP_OK) {
83 ReportResponse("CrxFileSystemCallback", pp_error);
84 return;
85 }
86
87 file_io_ = pp::FileIO(handle_);
88 file_ref_ = pp::FileRef(file_system, filename_.c_str());
89 int32_t rv = file_io_.Open(
90 file_ref_, PP_FILEOPENFLAG_READ,
91 factory_.NewCallback(&MyInstance::FileIOOpenCallback));
92 if (rv != PP_OK_COMPLETIONPENDING)
93 ReportResponse("FileIO::Open", rv);
94 }
95
FileIOOpenCallback(int32_t pp_error)96 void MyInstance::FileIOOpenCallback(int32_t pp_error) {
97 if (pp_error != PP_OK) {
98 ReportResponse("FileIOOpenCallback", pp_error);
99 return;
100 }
101
102 int32_t rv = file_io_.Read(0, read_buf_, sizeof(read_buf_),
103 factory_.NewCallback(&MyInstance::FileIOReadCallback));
104 if (rv != PP_OK_COMPLETIONPENDING) {
105 ReportResponse("FileIO::Read", rv);
106 return;
107 }
108 }
109
FileIOReadCallback(int32_t pp_error)110 void MyInstance::FileIOReadCallback(int32_t pp_error) {
111 if (pp_error < 0) {
112 ReportResponse("FileIOReadCallback", pp_error);
113 return;
114 }
115
116 std::string content;
117 content.append(read_buf_, pp_error);
118 PostMessage(pp::Var(content));
119 }
120
ReportResponse(const char * name,int32_t rv)121 void MyInstance::ReportResponse(const char* name, int32_t rv) {
122 std::ostringstream out;
123 out << name << " failed, pp_error: " << rv;
124 PostMessage(pp::Var(out.str()));
125 }
126
127 // This object is the global object representing this plugin library as long
128 // as it is loaded.
129 class MyModule : public pp::Module {
130 public:
MyModule()131 MyModule() : pp::Module() {}
~MyModule()132 virtual ~MyModule() {}
133
134 // Override CreateInstance to create your customized Instance object.
CreateInstance(PP_Instance instance)135 virtual pp::Instance* CreateInstance(PP_Instance instance) {
136 return new MyInstance(instance);
137 }
138 };
139
140 namespace pp {
141
142 // Factory function for your specialization of the Module object.
CreateModule()143 Module* CreateModule() {
144 return new MyModule();
145 }
146
147 } // namespace pp
148
149