Move data pack from base to app (it's just part of the resource bundle system...

app/data_pack.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 "base/data_pack.h"
+#include "app/data_pack.h"
 
 #include <errno.h>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/ref_counted_memory.h"
 #include "base/string_piece.h"
 
 // For details of the file layout, see
@@ skipping 36 matching lines @@
   INIT_FAILED = 1,
   BAD_VERSION,
   INDEX_TRUNCATED,
   ENTRY_NOT_FOUND,
 
   LOAD_ERRORS_COUNT,
 };
 
 }  // anonymous namespace
 
-namespace base {
+namespace app {
 
 // In .cc for MemoryMappedFile dtor.
 DataPack::DataPack() : resource_count_(0) {
 }
 DataPack::~DataPack() {
 }
 
 bool DataPack::Load(const FilePath& path) {
   mmap_.reset(new file_util::MemoryMappedFile);
   if (!mmap_->Initialize(path)) {
@@ skipping 38 matching lines @@
       UMA_HISTOGRAM_ENUMERATION("DataPack.Load", ENTRY_NOT_FOUND,
                                 LOAD_ERRORS_COUNT);
       mmap_.reset();
       return false;
     }
   }
 
   return true;
 }
 
-bool DataPack::GetStringPiece(uint32 resource_id, StringPiece* data) const {
+bool DataPack::GetStringPiece(uint32 resource_id,
+                              base::StringPiece* data) const {
   // It won't be hard to make this endian-agnostic, but it's not worth
   // bothering to do right now.
 #if defined(__BYTE_ORDER)
   // Linux check
   COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN,
                  datapack_assumes_little_endian);
 #elif defined(__BIG_ENDIAN__)
   // Mac check
   #error DataPack assumes little endian
 #endif
@@ skipping 13 matching lines @@
   base::StringPiece piece;
   if (!GetStringPiece(resource_id, &piece))
     return NULL;
 
   return new RefCountedStaticMemory(
       reinterpret_cast<const unsigned char*>(piece.data()), piece.length());
 }
 
 // static
 bool DataPack::WritePack(const FilePath& path,
-                         const std::map<uint32, StringPiece>& resources) {
+                         const std::map<uint32, base::StringPiece>& resources) {
   FILE* file = file_util::OpenFile(path, "wb");
   if (!file)
     return false;
 
   if (fwrite(&kFileFormatVersion, 1, kWord, file) != kWord) {
     LOG(ERROR) << "Failed to write file version";
     file_util::CloseFile(file);
     return false;
   }
 
   // Note: the python version of this function explicitly sorted keys, but
   // std::map is a sorted associative container, we shouldn't have to do that.
   uint32 entry_count = resources.size();
   if (fwrite(&entry_count, 1, kWord, file) != kWord) {
     LOG(ERROR) << "Failed to write entry count";
     file_util::CloseFile(file);
     return false;
   }
 
   // Each entry is 3 uint32s.
   uint32 index_length = entry_count * 3 * kWord;
   uint32 data_offset = kHeaderLength + index_length;
-  for (std::map<uint32, StringPiece>::const_iterator it = resources.begin();
+  for (std::map<uint32, base::StringPiece>::const_iterator it =
+           resources.begin();
        it != resources.end(); ++it) {
     if (fwrite(&it->first, 1, kWord, file) != kWord) {
       LOG(ERROR) << "Failed to write id for " << it->first;
       file_util::CloseFile(file);
       return false;
     }
 
     if (fwrite(&data_offset, 1, kWord, file) != kWord) {
       LOG(ERROR) << "Failed to write offset for " << it->first;
       file_util::CloseFile(file);
       return false;
     }
 
     uint32 len = it->second.length();
     if (fwrite(&len, 1, kWord, file) != kWord) {
       LOG(ERROR) << "Failed to write length for " << it->first;
       file_util::CloseFile(file);
       return false;
     }
 
     data_offset += len;
   }
 
-  for (std::map<uint32, StringPiece>::const_iterator it = resources.begin();
+  for (std::map<uint32, base::StringPiece>::const_iterator it =
+           resources.begin();
        it != resources.end(); ++it) {
     if (fwrite(it->second.data(), it->second.length(), 1, file) != 1) {
       LOG(ERROR) << "Failed to write data for " << it->first;
       file_util::CloseFile(file);
       return false;
     }
   }
 
   file_util::CloseFile(file);
 
   return true;
 }
 
-}  // namespace base
+}  // namespace app