[BlobAsync] Moving async handling into BlobStorageContext & quota out.

storage/browser/blob/view_blob_internals_job.cc

 // Copyright (c) 2012 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 "storage/browser/blob/view_blob_internals_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request.h"
 #include "storage/browser/blob/blob_data_item.h"
+#include "storage/browser/blob/blob_entry.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_storage_registry.h"
-#include "storage/browser/blob/internal_blob_data.h"
+#include "storage/browser/blob/shareable_blob_data_item.h"
 
 namespace {
 
 const char kEmptyBlobStorageMessage[] = "No available blob data.";
 const char kContentType[] = "Content Type: ";
 const char kContentDisposition[] = "Content Disposition: ";
 const char kCount[] = "Count: ";
 const char kIndex[] = "Index: ";
 const char kType[] = "Type: ";
 const char kPath[] = "Path: ";
@@ skipping 95 matching lines @@
 int ViewBlobInternalsJob::GetData(
     std::string* mime_type,
     std::string* charset,
     std::string* data,
     const net::CompletionCallback& callback) const {
   mime_type->assign("text/html");
   charset->assign("UTF-8");
 
   data->clear();
   StartHTML(data);
-  if (blob_storage_context_->registry_.blob_map_.empty())
+  if (blob_storage_context_->registry().blob_map_.empty())
     data->append(kEmptyBlobStorageMessage);
   else
     GenerateHTML(data);
   EndHTML(data);
   return net::OK;
 }
 
 void ViewBlobInternalsJob::GenerateHTML(std::string* out) const {
   for (BlobStorageRegistry::BlobMap::const_iterator iter =
-           blob_storage_context_->registry_.blob_map_.begin();
-       iter != blob_storage_context_->registry_.blob_map_.end(); ++iter) {
+           blob_storage_context_->registry().blob_map_.begin();
+       iter != blob_storage_context_->registry().blob_map_.end(); ++iter) {
     AddHTMLBoldText(iter->first, out);
-    GenerateHTMLForBlobData(*iter->second->data, iter->second->content_type,
-                            iter->second->content_disposition,
-                            iter->second->refcount, out);
+    GenerateHTMLForBlobData(*iter->second, iter->second->content_type(),
+                            iter->second->content_disposition(),
+                            iter->second->refcount(), out);
   }
-  if (!blob_storage_context_->registry_.url_to_uuid_.empty()) {
+  if (!blob_storage_context_->registry().url_to_uuid_.empty()) {
     AddHorizontalRule(out);
     for (BlobStorageRegistry::URLMap::const_iterator iter =
-             blob_storage_context_->registry_.url_to_uuid_.begin();
-         iter != blob_storage_context_->registry_.url_to_uuid_.end(); ++iter) {
+             blob_storage_context_->registry().url_to_uuid_.begin();
+         iter != blob_storage_context_->registry().url_to_uuid_.end(); ++iter) {
       AddHTMLBoldText(iter->first.spec(), out);
       StartHTMLList(out);
       AddHTMLListItem(kUUID, iter->second, out);
       EndHTMLList(out);
     }
   }
 }
 
 void ViewBlobInternalsJob::GenerateHTMLForBlobData(
-    const InternalBlobData& blob_data,
+    const BlobEntry& blob_data,
     const std::string& content_type,
     const std::string& content_disposition,
     int refcount,
     std::string* out) {
   StartHTMLList(out);
 
   AddHTMLListItem(kRefcount, base::IntToString(refcount), out);
   if (!content_type.empty())
     AddHTMLListItem(kContentType, content_type, out);
   if (!content_disposition.empty())
@@ skipping 37 matching lines @@
           AddHTMLListItem(kModificationTime, base::UTF16ToUTF8(
               TimeFormatFriendlyDateAndTime(item.expected_modification_time())),
               out);
         }
         break;
       case DataElement::TYPE_DISK_CACHE_ENTRY:
         AddHTMLListItem(kType, "disk cache entry", out);
         AddHTMLListItem(kURL, item.disk_cache_entry()->GetKey(), out);
         break;
       case DataElement::TYPE_BYTES_DESCRIPTION:
+        AddHTMLListItem(kType, "pending data", out);
       case DataElement::TYPE_UNKNOWN:
         NOTREACHED();
         break;
     }
     if (item.offset()) {
       AddHTMLListItem(kOffset, base::UTF16ToUTF8(base::FormatNumber(
                                    static_cast<int64_t>(item.offset()))),
                       out);
     }
     if (static_cast<int64_t>(item.length()) != -1) {
       AddHTMLListItem(kLength, base::UTF16ToUTF8(base::FormatNumber(
                                    static_cast<int64_t>(item.length()))),
                       out);
     }
 
     if (has_multi_items)
       EndHTMLList(out);
   }
 
   EndHTMLList(out);
 }
 
 }  // namespace storage