Add function to document_loader to get PDF as pp::FileRef

pdf/document_loader.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "pdf/document_loader.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/dev/buffer_dev.h"
 #include "ppapi/cpp/url_loader.h"
 #include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/url_response_info.h"
 
 namespace chrome_pdf {
 
 // Document below size will be downloaded in one chunk.
 const uint32 kMinFileSize = 64*1024;
 
 DocumentLoader::DocumentLoader(Client* client)
@@ skipping 99 matching lines @@
   chunk_buffer_.clear();
   ReadMore();
 }
 
 bool DocumentLoader::IsDocumentComplete() const {
   if (document_size_ == 0)  // Document size unknown.
     return false;
   return IsDataAvailable(0, document_size_);
 }
 
+void DocumentLoader::GetCompleteDocument(
+    pp::CompletionCallbackWithOutput<pp::FileRef> callback) {
+  if (!IsDocumentComplete() || chunk_stream_.data().empty()) {
+    callback.Run(PP_ERROR_FAILED);
+    return;
+  }
+
+  if (!file_writer_) {
+    file_writer_.reset(new FileWriter(
+        client_->GetPluginInstance(),
+        "pdf",
+        reinterpret_cast<const char*>(&chunk_stream_.data()[0]),
+        chunk_stream_.data().size()));
+  }
+
+  file_writer_->GetFile(callback);
+}
+
 uint32 DocumentLoader::GetAvailableData() const {
   if (document_size_ == 0) {  // If document size is unknown.
     return current_pos_;
   }
 
   std::vector<std::pair<size_t, size_t> > ranges;
   chunk_stream_.GetMissedRanges(0, document_size_, &ranges);
   uint32 available = document_size_;
   std::vector<std::pair<size_t, size_t> >::iterator it;
   for (it = ranges.begin(); it != ranges.end(); ++it) {
@@ skipping 355 matching lines @@
 uint32 DocumentLoader::GetRequestSize() const {
   // Document loading strategy:
   // For first 10 requests, we use 32k chunk sizes, for the next 10 requests we
   // double the size (64k), and so on, until we cap max request size at 2M for
   // 71 or more requests.
   uint32 limited_count = std::min(std::max(requests_count_, 10u), 70u);
   return 32*1024 * (1 << ((limited_count - 1) / 10u));
 }
 
 }  // namespace chrome_pdf