[Storage] Blob Storage Refactoring pt 1

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 "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/logging.h"
 #include "base/message_loop/message_loop.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 "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
+#include "storage/browser/blob/blob_data_snapshot.h"
 #include "storage/browser/blob/blob_storage_context.h"
-#include "storage/common/blob/blob_data.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 110 matching lines @@
   EndHTML(data);
   return net::OK;
 }
 
 void ViewBlobInternalsJob::GenerateHTML(std::string* out) const {
   for (BlobStorageContext::BlobMap::const_iterator iter =
            blob_storage_context_->blob_map_.begin();
        iter != blob_storage_context_->blob_map_.end();
        ++iter) {
     AddHTMLBoldText(iter->first, out);
-    GenerateHTMLForBlobData(*(iter->second.data.get()),
-                            iter->second.refcount,
+    GenerateHTMLForBlobData(*(iter->second->data.get()), iter->second->refcount,
                             out);
   }
   if (!blob_storage_context_->public_blob_urls_.empty()) {
     AddHorizontalRule(out);
     for (BlobStorageContext::BlobURLMap::const_iterator iter =
              blob_storage_context_->public_blob_urls_.begin();
          iter != blob_storage_context_->public_blob_urls_.end();
          ++iter) {
       AddHTMLBoldText(iter->first.spec(), out);
       StartHTMLList(out);
       AddHTMLListItem(kUUID, iter->second, out);
       EndHTMLList(out);
     }
   }
 }
 
-void ViewBlobInternalsJob::GenerateHTMLForBlobData(const BlobData& blob_data,
-                                                   int refcount,
-                                                   std::string* out) {
+void ViewBlobInternalsJob::GenerateHTMLForBlobData(
+    const BlobDataSnapshot& blob_data,
+    int refcount,
+    std::string* out) {
   StartHTMLList(out);
 
   AddHTMLListItem(kRefcount, base::IntToString(refcount), out);
   if (!blob_data.content_type().empty())
     AddHTMLListItem(kContentType, blob_data.content_type(), out);
   if (!blob_data.content_disposition().empty())
     AddHTMLListItem(kContentDisposition, blob_data.content_disposition(), out);
 
   bool has_multi_items = blob_data.items().size() > 1;
   if (has_multi_items) {
     AddHTMLListItem(kCount,
         base::UTF16ToUTF8(base::FormatNumber(blob_data.items().size())), out);
   }
 
   for (size_t i = 0; i < blob_data.items().size(); ++i) {
     if (has_multi_items) {
       AddHTMLListItem(kIndex, base::UTF16ToUTF8(base::FormatNumber(i)), out);
       StartHTMLList(out);
     }
-    const BlobData::Item& item = blob_data.items().at(i);
+    const BlobDataItem& item = *(blob_data.items().at(i));
 
     switch (item.type()) {
-      case BlobData::Item::TYPE_BYTES:
+      case DataElement::TYPE_BYTES:
         AddHTMLListItem(kType, "data", out);
         break;
-      case BlobData::Item::TYPE_FILE:
+      case DataElement::TYPE_FILE:
         AddHTMLListItem(kType, "file", out);
         AddHTMLListItem(kPath,
                  net::EscapeForHTML(item.path().AsUTF8Unsafe()),
                  out);
         if (!item.expected_modification_time().is_null()) {
           AddHTMLListItem(kModificationTime, base::UTF16ToUTF8(
               TimeFormatFriendlyDateAndTime(item.expected_modification_time())),
               out);
         }
         break;
-      case BlobData::Item::TYPE_BLOB:
+      case DataElement::TYPE_BLOB:
         NOTREACHED();   // Should be flattened in the storage context.
         break;
-      case BlobData::Item::TYPE_FILE_FILESYSTEM:
+      case DataElement::TYPE_FILE_FILESYSTEM:
         AddHTMLListItem(kType, "filesystem", out);
         AddHTMLListItem(kURL, item.filesystem_url().spec(), out);
         if (!item.expected_modification_time().is_null()) {
           AddHTMLListItem(kModificationTime, base::UTF16ToUTF8(
               TimeFormatFriendlyDateAndTime(item.expected_modification_time())),
               out);
         }
         break;
-      case BlobData::Item::TYPE_UNKNOWN:
+      case DataElement::TYPE_UNKNOWN:
         NOTREACHED();
         break;
     }
     if (item.offset()) {
       AddHTMLListItem(kOffset, base::UTF16ToUTF8(base::FormatNumber(
           static_cast<int64>(item.offset()))), out);
     }
     if (static_cast<int64>(item.length()) != -1) {
       AddHTMLListItem(kLength, base::UTF16ToUTF8(base::FormatNumber(
           static_cast<int64>(item.length()))), out);
     }
 
     if (has_multi_items)
       EndHTMLList(out);
   }
 
   EndHTMLList(out);
 }
 
 }  // namespace storage