Move chrome/browser/nacl_host/pnacl_translation_cache.* to components/nacl/browser

These files have no dependencies on chrome/ so they can be safely moved
to the components/ directory.

This is part of an effort to componentize NaCl code.

BUG=244791

Review URL: https://codereview.chromium.org/61763026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@235735 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 2 insertions, 823 deletions

diff --git a/chrome/browser/nacl_host/pnacl_host.cc b/chrome/browser/nacl_host/pnacl_host.cc
index 0ee7a137..6a974cd 100644
--- a/chrome/browser/nacl_host/pnacl_host.cc
+++ b/chrome/browser/nacl_host/pnacl_host.cc
@@ -11,8 +11,8 @@
 #include "base/logging.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/nacl_host/pnacl_translation_cache.h"
 #include "components/nacl/browser/nacl_browser.h"
+#include "components/nacl/browser/pnacl_translation_cache.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
diff --git a/chrome/browser/nacl_host/pnacl_host_unittest.cc b/chrome/browser/nacl_host/pnacl_host_unittest.cc
index df4a32d..c4678f7 100644
--- a/chrome/browser/nacl_host/pnacl_host_unittest.cc
+++ b/chrome/browser/nacl_host/pnacl_host_unittest.cc
@@ -9,7 +9,7 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/nacl_host/pnacl_translation_cache.h"
+#include "components/nacl/browser/pnacl_translation_cache.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/test_completion_callback.h"
diff --git a/chrome/browser/nacl_host/pnacl_translation_cache.cc b/chrome/browser/nacl_host/pnacl_translation_cache.cc
deleted file mode 100644
index 5635479..0000000
--- a/chrome/browser/nacl_host/pnacl_translation_cache.cc
+++ /dev/null
@@ -1,440 +0,0 @@
-// Copyright 2013 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 "chrome/browser/nacl_host/pnacl_translation_cache.h"
-
-#include <string>
-
-#include "base/callback.h"
-#include "base/files/file_path.h"
-#include "base/logging.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/threading/thread_checker.h"
-#include "components/nacl/common/pnacl_types.h"
-#include "content/public/browser/browser_thread.h"
-#include "net/base/io_buffer.h"
-#include "net/base/net_errors.h"
-#include "net/disk_cache/disk_cache.h"
-
-using base::IntToString;
-using content::BrowserThread;
-
-namespace {
-
-void CloseDiskCacheEntry(disk_cache::Entry* entry) { entry->Close(); }
-
-}  // namespace
-
-namespace pnacl {
-// This is in pnacl namespace instead of static so they can be used
-// by the unit test.
-const int kMaxMemCacheSize = 100 * 1024 * 1024;
-
-//////////////////////////////////////////////////////////////////////
-// Handle Reading/Writing to Cache.
-
-// PnaclTranslationCacheEntry is a shim that provides storage for the
-// 'key' and 'data' strings as the disk_cache is performing various async
-// operations. It also tracks the open disk_cache::Entry
-// and ensures that the entry is closed.
-class PnaclTranslationCacheEntry
-    : public base::RefCounted<PnaclTranslationCacheEntry> {
- public:
-  static PnaclTranslationCacheEntry* GetReadEntry(
-      base::WeakPtr<PnaclTranslationCache> cache,
-      const std::string& key,
-      const GetNexeCallback& callback);
-  static PnaclTranslationCacheEntry* GetWriteEntry(
-      base::WeakPtr<PnaclTranslationCache> cache,
-      const std::string& key,
-      net::DrainableIOBuffer* write_nexe,
-      const CompletionCallback& callback);
-
-  void Start();
-
-  // Writes:                                ---
-  //                                        v  |
-  // Start -> Open Existing --------------> Write ---> Close
-  //                          \              ^
-  //                           \             /
-  //                            --> Create --
-  // Reads:
-  // Start -> Open --------Read ----> Close
-  //                       |  ^
-  //                       |__|
-  enum CacheStep {
-    UNINITIALIZED,
-    OPEN_ENTRY,
-    CREATE_ENTRY,
-    TRANSFER_ENTRY,
-    CLOSE_ENTRY,
-    FINISHED
-  };
-
- private:
-  friend class base::RefCounted<PnaclTranslationCacheEntry>;
-  PnaclTranslationCacheEntry(base::WeakPtr<PnaclTranslationCache> cache,
-                             const std::string& key,
-                             bool is_read);
-  ~PnaclTranslationCacheEntry();
-
-  // Try to open an existing entry in the backend
-  void OpenEntry();
-  // Create a new entry in the backend (for writes)
-  void CreateEntry();
-  // Write |len| bytes to the backend, starting at |offset|
-  void WriteEntry(int offset, int len);
-  // Read |len| bytes from the backend, starting at |offset|
-  void ReadEntry(int offset, int len);
-  // If there was an error, doom the entry. Then post a task to the IO
-  // thread to close (and delete) it.
-  void CloseEntry(int rv);
-  // Call the user callback, and signal to the cache to delete this.
-  void Finish(int rv);
-  // Used as the callback for all operations to the backend. Handle state
-  // transitions, track bytes transferred, and call the other helper methods.
-  void DispatchNext(int rv);
-
-  base::WeakPtr<PnaclTranslationCache> cache_;
-  std::string key_;
-  disk_cache::Entry* entry_;
-  CacheStep step_;
-  bool is_read_;
-  GetNexeCallback read_callback_;
-  CompletionCallback write_callback_;
-  scoped_refptr<net::DrainableIOBuffer> io_buf_;
-  base::ThreadChecker thread_checker_;
-  DISALLOW_COPY_AND_ASSIGN(PnaclTranslationCacheEntry);
-};
-
-// static
-PnaclTranslationCacheEntry* PnaclTranslationCacheEntry::GetReadEntry(
-    base::WeakPtr<PnaclTranslationCache> cache,
-    const std::string& key,
-    const GetNexeCallback& callback) {
-  PnaclTranslationCacheEntry* entry(
-      new PnaclTranslationCacheEntry(cache, key, true));
-  entry->read_callback_ = callback;
-  return entry;
-}
-
-// static
-PnaclTranslationCacheEntry* PnaclTranslationCacheEntry::GetWriteEntry(
-    base::WeakPtr<PnaclTranslationCache> cache,
-    const std::string& key,
-    net::DrainableIOBuffer* write_nexe,
-    const CompletionCallback& callback) {
-  PnaclTranslationCacheEntry* entry(
-      new PnaclTranslationCacheEntry(cache, key, false));
-  entry->io_buf_ = write_nexe;
-  entry->write_callback_ = callback;
-  return entry;
-}
-
-PnaclTranslationCacheEntry::PnaclTranslationCacheEntry(
-    base::WeakPtr<PnaclTranslationCache> cache,
-    const std::string& key,
-    bool is_read)
-    : cache_(cache),
-      key_(key),
-      entry_(NULL),
-      step_(UNINITIALIZED),
-      is_read_(is_read) {}
-
-PnaclTranslationCacheEntry::~PnaclTranslationCacheEntry() {
-  // Ensure we have called the user's callback
-  if (step_ != FINISHED) {
-    if (!read_callback_.is_null()) {
-      BrowserThread::PostTask(
-          BrowserThread::IO,
-          FROM_HERE,
-          base::Bind(read_callback_,
-                     net::ERR_ABORTED,
-                     scoped_refptr<net::DrainableIOBuffer>()));
-    }
-    if (!write_callback_.is_null()) {
-      BrowserThread::PostTask(BrowserThread::IO,
-                              FROM_HERE,
-                              base::Bind(write_callback_, net::ERR_ABORTED));
-    }
-  }
-}
-
-void PnaclTranslationCacheEntry::Start() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  step_ = OPEN_ENTRY;
-  OpenEntry();
-}
-
-// OpenEntry, CreateEntry, WriteEntry, ReadEntry and CloseEntry are only called
-// from DispatchNext, so they know that cache_ is still valid.
-void PnaclTranslationCacheEntry::OpenEntry() {
-  int rv = cache_->backend()->OpenEntry(
-      key_,
-      &entry_,
-      base::Bind(&PnaclTranslationCacheEntry::DispatchNext, this));
-  if (rv != net::ERR_IO_PENDING)
-    DispatchNext(rv);
-}
-
-void PnaclTranslationCacheEntry::CreateEntry() {
-  int rv = cache_->backend()->CreateEntry(
-      key_,
-      &entry_,
-      base::Bind(&PnaclTranslationCacheEntry::DispatchNext, this));
-  if (rv != net::ERR_IO_PENDING)
-    DispatchNext(rv);
-}
-
-void PnaclTranslationCacheEntry::WriteEntry(int offset, int len) {
-  DCHECK(io_buf_->BytesRemaining() == len);
-  int rv = entry_->WriteData(
-      1,
-      offset,
-      io_buf_.get(),
-      len,
-      base::Bind(&PnaclTranslationCacheEntry::DispatchNext, this),
-      false);
-  if (rv != net::ERR_IO_PENDING)
-    DispatchNext(rv);
-}
-
-void PnaclTranslationCacheEntry::ReadEntry(int offset, int len) {
-  int rv = entry_->ReadData(
-      1,
-      offset,
-      io_buf_.get(),
-      len,
-      base::Bind(&PnaclTranslationCacheEntry::DispatchNext, this));
-  if (rv != net::ERR_IO_PENDING)
-    DispatchNext(rv);
-}
-
-void PnaclTranslationCacheEntry::CloseEntry(int rv) {
-  DCHECK(entry_);
-  if (rv < 0) {
-    LOG(ERROR) << "Failed to close entry: " << net::ErrorToString(rv);
-    entry_->Doom();
-  }
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(&CloseDiskCacheEntry, entry_));
-  Finish(rv);
-}
-
-void PnaclTranslationCacheEntry::Finish(int rv) {
-  step_ = FINISHED;
-  if (is_read_) {
-    if (!read_callback_.is_null()) {
-      BrowserThread::PostTask(BrowserThread::IO,
-                              FROM_HERE,
-                              base::Bind(read_callback_, rv, io_buf_));
-    }
-  } else {
-    if (!write_callback_.is_null()) {
-      BrowserThread::PostTask(
-          BrowserThread::IO, FROM_HERE, base::Bind(write_callback_, rv));
-    }
-  }
-  cache_->OpComplete(this);
-}
-
-void PnaclTranslationCacheEntry::DispatchNext(int rv) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!cache_)
-    return;
-
-  switch (step_) {
-    case UNINITIALIZED:
-    case FINISHED:
-      LOG(ERROR) << "DispatchNext called uninitialized";
-      break;
-
-    case OPEN_ENTRY:
-      if (rv == net::OK) {
-        step_ = TRANSFER_ENTRY;
-        if (is_read_) {
-          int bytes_to_transfer = entry_->GetDataSize(1);
-          io_buf_ = new net::DrainableIOBuffer(
-              new net::IOBuffer(bytes_to_transfer), bytes_to_transfer);
-          ReadEntry(0, bytes_to_transfer);
-        } else {
-          WriteEntry(0, io_buf_->size());
-        }
-      } else {
-        if (rv != net::ERR_FAILED) {
-          // ERROR_FAILED is what we expect if the entry doesn't exist.
-          LOG(ERROR) << "OpenEntry failed: " << net::ErrorToString(rv);
-        }
-        if (is_read_) {
-          // Just a cache miss, not necessarily an error.
-          entry_ = NULL;
-          Finish(rv);
-        } else {
-          step_ = CREATE_ENTRY;
-          CreateEntry();
-        }
-      }
-      break;
-
-    case CREATE_ENTRY:
-      if (rv == net::OK) {
-        step_ = TRANSFER_ENTRY;
-        WriteEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining());
-      } else {
-        LOG(ERROR) << "Failed to Create Entry: " << net::ErrorToString(rv);
-        Finish(rv);
-      }
-      break;
-
-    case TRANSFER_ENTRY:
-      if (rv < 0) {
-        // We do not call DispatchNext directly if WriteEntry/ReadEntry returns
-        // ERR_IO_PENDING, and the callback should not return that value either.
-        LOG(ERROR) << "Failed to complete write to entry: "
-                   << net::ErrorToString(rv);
-        step_ = CLOSE_ENTRY;
-        CloseEntry(rv);
-        break;
-      } else if (rv > 0) {
-        io_buf_->DidConsume(rv);
-        if (io_buf_->BytesRemaining() > 0) {
-          is_read_
-              ? ReadEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining())
-              : WriteEntry(io_buf_->BytesConsumed(), io_buf_->BytesRemaining());
-          break;
-        }
-      }
-      // rv == 0 or we fell through (i.e. we have transferred all the bytes)
-      step_ = CLOSE_ENTRY;
-      DCHECK(io_buf_->BytesConsumed() == io_buf_->size());
-      if (is_read_)
-        io_buf_->SetOffset(0);
-      CloseEntry(0);
-      break;
-
-    case CLOSE_ENTRY:
-      step_ = UNINITIALIZED;
-      break;
-  }
-}
-
-//////////////////////////////////////////////////////////////////////
-void PnaclTranslationCache::OpComplete(PnaclTranslationCacheEntry* entry) {
-  open_entries_.erase(entry);
-}
-
-//////////////////////////////////////////////////////////////////////
-// Construction and cache backend initialization
-PnaclTranslationCache::PnaclTranslationCache() : in_memory_(false) {}
-
-PnaclTranslationCache::~PnaclTranslationCache() {}
-
-int PnaclTranslationCache::Init(net::CacheType cache_type,
-                                const base::FilePath& cache_dir,
-                                int cache_size,
-                                const CompletionCallback& callback) {
-  int rv = disk_cache::CreateCacheBackend(
-      cache_type,
-      net::CACHE_BACKEND_DEFAULT,
-      cache_dir,
-      cache_size,
-      true /* force_initialize */,
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
-      NULL, /* dummy net log */
-      &disk_cache_,
-      base::Bind(&PnaclTranslationCache::OnCreateBackendComplete, AsWeakPtr()));
-  if (rv == net::ERR_IO_PENDING) {
-    init_callback_ = callback;
-  }
-  return rv;
-}
-
-void PnaclTranslationCache::OnCreateBackendComplete(int rv) {
-  if (rv < 0) {
-    LOG(ERROR) << "Backend init failed:" << net::ErrorToString(rv);
-  }
-  // Invoke our client's callback function.
-  if (!init_callback_.is_null()) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE, base::Bind(init_callback_, rv));
-  }
-}
-
-//////////////////////////////////////////////////////////////////////
-// High-level API
-
-void PnaclTranslationCache::StoreNexe(const std::string& key,
-                                      net::DrainableIOBuffer* nexe_data,
-                                      const CompletionCallback& callback) {
-  PnaclTranslationCacheEntry* entry = PnaclTranslationCacheEntry::GetWriteEntry(
-      AsWeakPtr(), key, nexe_data, callback);
-  open_entries_[entry] = entry;
-  entry->Start();
-}
-
-void PnaclTranslationCache::GetNexe(const std::string& key,
-                                    const GetNexeCallback& callback) {
-  PnaclTranslationCacheEntry* entry =
-      PnaclTranslationCacheEntry::GetReadEntry(AsWeakPtr(), key, callback);
-  open_entries_[entry] = entry;
-  entry->Start();
-}
-
-int PnaclTranslationCache::InitOnDisk(const base::FilePath& cache_directory,
-                                      const CompletionCallback& callback) {
-  in_memory_ = false;
-  return Init(net::PNACL_CACHE, cache_directory, 0 /* auto size */, callback);
-}
-
-int PnaclTranslationCache::InitInMemory(const CompletionCallback& callback) {
-  in_memory_ = true;
-  return Init(net::MEMORY_CACHE, base::FilePath(), kMaxMemCacheSize, callback);
-}
-
-int PnaclTranslationCache::Size() {
-  if (!disk_cache_)
-    return -1;
-  return disk_cache_->GetEntryCount();
-}
-
-// static
-std::string PnaclTranslationCache::GetKey(const nacl::PnaclCacheInfo& info) {
-  if (!info.pexe_url.is_valid() || info.abi_version < 0 || info.opt_level < 0)
-    return std::string();
-  std::string retval("ABI:");
-  retval += IntToString(info.abi_version) + ";" + "opt:" +
-            IntToString(info.opt_level) + ";" + "URL:";
-  // Filter the username, password, and ref components from the URL
-  GURL::Replacements replacements;
-  replacements.ClearUsername();
-  replacements.ClearPassword();
-  replacements.ClearRef();
-  GURL key_url(info.pexe_url.ReplaceComponents(replacements));
-  retval += key_url.spec() + ";";
-  // You would think that there is already code to format base::Time values
-  // somewhere, but I haven't found it yet. In any case, doing it ourselves
-  // here means we can keep the format stable.
-  base::Time::Exploded exploded;
-  info.last_modified.UTCExplode(&exploded);
-  if (info.last_modified.is_null() || !exploded.HasValidValues()) {
-    memset(&exploded, 0, sizeof(exploded));
-  }
-  retval += "modified:" + IntToString(exploded.year) + ":" +
-            IntToString(exploded.month) + ":" +
-            IntToString(exploded.day_of_month) + ":" +
-            IntToString(exploded.hour) + ":" + IntToString(exploded.minute) +
-            ":" + IntToString(exploded.second) + ":" +
-            IntToString(exploded.millisecond) + ":UTC;";
-  retval += "etag:" + info.etag;
-  return retval;
-}
-
-int PnaclTranslationCache::DoomEntriesBetween(
-    base::Time initial,
-    base::Time end,
-    const CompletionCallback& callback) {
-  return disk_cache_->DoomEntriesBetween(initial, end, callback);
-}
-
-}  // namespace pnacl
diff --git a/chrome/browser/nacl_host/pnacl_translation_cache.h b/chrome/browser/nacl_host/pnacl_translation_cache.h
deleted file mode 100644
index 7ca4bcc..0000000
--- a/chrome/browser/nacl_host/pnacl_translation_cache.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Copyright 2013 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.
-
-#ifndef CHROME_BROWSER_NACL_HOST_PNACL_TRANSLATION_CACHE_H_
-#define CHROME_BROWSER_NACL_HOST_PNACL_TRANSLATION_CACHE_H_
-
-#include <map>
-
-#include "base/callback.h"
-#include "base/files/file_path.h"
-#include "base/memory/weak_ptr.h"
-#include "base/time/time.h"
-#include "net/base/cache_type.h"
-
-namespace base {
-class MessageLoopProxy;
-}
-
-namespace disk_cache {
-class Backend;
-}
-
-namespace nacl {
-struct PnaclCacheInfo;
-}
-
-namespace net {
-class DrainableIOBuffer;
-}
-
-namespace pnacl {
-typedef base::Callback<void(int)> CompletionCallback;
-typedef base::Callback<void(int, scoped_refptr<net::DrainableIOBuffer>)>
-    GetNexeCallback;
-class PnaclTranslationCacheEntry;
-extern const int kMaxMemCacheSize;
-
-class PnaclTranslationCache
-    : public base::SupportsWeakPtr<PnaclTranslationCache> {
- public:
-  PnaclTranslationCache();
-  virtual ~PnaclTranslationCache();
-
-  // Initialize the translation cache in |cache_dir|.  If the return value is
-  // net::ERR_IO_PENDING, |callback| will be called with a 0 argument on sucess
-  // and <0 otherwise.
-  int InitOnDisk(const base::FilePath& cache_dir,
-                 const CompletionCallback& callback);
-
-  // Initialize the translation cache in memory.  If the return value is
-  // net::ERR_IO_PENDING, |callback| will be called with a 0 argument on sucess
-  // and <0 otherwise.
-  int InitInMemory(const CompletionCallback& callback);
-
-  // Store the nexe in the translation cache, and call |callback| with
-  // the result. The result passed to the callback is 0 on success and
-  // <0 otherwise. A reference to |nexe_data| is held until completion
-  // or cancellation.
-  void StoreNexe(const std::string& key,
-                 net::DrainableIOBuffer* nexe_data,
-                 const CompletionCallback& callback);
-
-  // Retrieve the nexe from the translation cache. Write the data into |nexe|
-  // and call |callback|, passing a result code (0 on success and <0 otherwise),
-  // and a DrainableIOBuffer with the data.
-  void GetNexe(const std::string& key, const GetNexeCallback& callback);
-
-  // Return the number of entries in the cache backend.
-  int Size();
-
-  // Return the cache key for |info|
-  static std::string GetKey(const nacl::PnaclCacheInfo& info);
-
-  // Doom all entries between |initial| and |end|. If the return value is
-  // net::ERR_IO_PENDING, |callback| will be invoked when the operation
-  // completes.
-  int DoomEntriesBetween(base::Time initial, base::Time end,
-                         const CompletionCallback& callback);
-
- private:
-  friend class PnaclTranslationCacheEntry;
-  friend class PnaclTranslationCacheTest;
-  // PnaclTranslationCacheEntry should only use the
-  // OpComplete and backend methods on PnaclTranslationCache.
-  void OpComplete(PnaclTranslationCacheEntry* entry);
-  disk_cache::Backend* backend() { return disk_cache_.get(); }
-
-  int Init(net::CacheType,
-           const base::FilePath& directory,
-           int cache_size,
-           const CompletionCallback& callback);
-
-  void OnCreateBackendComplete(int rv);
-
-  scoped_ptr<disk_cache::Backend> disk_cache_;
-  CompletionCallback init_callback_;
-  bool in_memory_;
-  std::map<void*, scoped_refptr<PnaclTranslationCacheEntry> > open_entries_;
-
-  DISALLOW_COPY_AND_ASSIGN(PnaclTranslationCache);
-};
-
-}  // namespace pnacl
-
-#endif  // CHROME_BROWSER_NACL_HOST_PNACL_TRANSLATION_CACHE_H_
diff --git a/chrome/browser/nacl_host/pnacl_translation_cache_unittest.cc b/chrome/browser/nacl_host/pnacl_translation_cache_unittest.cc
deleted file mode 100644
index adcdd35b..0000000
--- a/chrome/browser/nacl_host/pnacl_translation_cache_unittest.cc
+++ /dev/null
@@ -1,269 +0,0 @@
-// Copyright 2013 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 "chrome/browser/nacl_host/pnacl_translation_cache.h"
-
-#include "base/files/file_path.h"
-#include "base/files/scoped_temp_dir.h"
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
-#include "components/nacl/common/pnacl_types.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/test/test_browser_thread_bundle.h"
-#include "net/base/io_buffer.h"
-#include "net/base/test_completion_callback.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using content::BrowserThread;
-using base::FilePath;
-
-namespace pnacl {
-
-const int kTestDiskCacheSize = 16 * 1024 * 1024;
-
-class PnaclTranslationCacheTest : public testing::Test {
- protected:
-  PnaclTranslationCacheTest()
-      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
-  virtual ~PnaclTranslationCacheTest() {}
-  virtual void SetUp() { cache_.reset(new PnaclTranslationCache()); }
-  virtual void TearDown() {
-    // The destructor of PnaclTranslationCacheWriteEntry posts a task to the IO
-    // thread to close the backend cache entry. We want to make sure the entries
-    // are closed before we delete the backend (and in particular the destructor
-    // for the memory backend has a DCHECK to verify this), so we run the loop
-    // here to ensure the task gets processed.
-    base::RunLoop().RunUntilIdle();
-    cache_.reset();
-  }
-
-  void InitBackend(bool in_mem);
-  void StoreNexe(const std::string& key, const std::string& nexe);
-  std::string GetNexe(const std::string& key);
-
-  scoped_ptr<PnaclTranslationCache> cache_;
-  content::TestBrowserThreadBundle thread_bundle_;
-  base::ScopedTempDir temp_dir_;
-};
-
-void PnaclTranslationCacheTest::InitBackend(bool in_mem) {
-  net::TestCompletionCallback init_cb;
-  if (!in_mem) {
-    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-  }
-  // Use the private init method so we can control the size
-  int rv = cache_->Init(in_mem ? net::MEMORY_CACHE : net::PNACL_CACHE,
-                        temp_dir_.path(),
-                        in_mem ? kMaxMemCacheSize : kTestDiskCacheSize,
-                        init_cb.callback());
-  if (in_mem)
-    ASSERT_EQ(net::OK, rv);
-  ASSERT_EQ(net::OK, init_cb.GetResult(rv));
-  ASSERT_EQ(0, cache_->Size());
-}
-
-void PnaclTranslationCacheTest::StoreNexe(const std::string& key,
-                                          const std::string& nexe) {
-  net::TestCompletionCallback store_cb;
-  scoped_refptr<net::DrainableIOBuffer> nexe_buf(
-      new net::DrainableIOBuffer(new net::StringIOBuffer(nexe), nexe.size()));
-  cache_->StoreNexe(key, nexe_buf, store_cb.callback());
-  // Using ERR_IO_PENDING here causes the callback to wait for the result
-  // which should be harmless even if it returns OK immediately. This is because
-  // we don't plumb the intermediate writing stages all the way out.
-  EXPECT_EQ(net::OK, store_cb.GetResult(net::ERR_IO_PENDING));
-}
-
-// Inspired by net::TestCompletionCallback. Instantiate a TestNexeCallback and
-// pass the GetNexeCallback returned by the callback() method to GetNexe.
-// Then call GetResult, which will pump the message loop until it gets a result,
-// return the resulting IOBuffer and fill in the return value
-class TestNexeCallback {
- public:
-  TestNexeCallback()
-      : have_result_(false),
-        result_(-1),
-        cb_(base::Bind(&TestNexeCallback::SetResult, base::Unretained(this))) {}
-  GetNexeCallback callback() { return cb_; }
-  net::DrainableIOBuffer* GetResult(int* result) {
-    while (!have_result_)
-      base::RunLoop().RunUntilIdle();
-    have_result_ = false;
-    *result = result_;
-    return buf_.get();
-  }
-
- private:
-  void SetResult(int rv, scoped_refptr<net::DrainableIOBuffer> buf) {
-    have_result_ = true;
-    result_ = rv;
-    buf_ = buf;
-  }
-  bool have_result_;
-  int result_;
-  scoped_refptr<net::DrainableIOBuffer> buf_;
-  const GetNexeCallback cb_;
-};
-
-std::string PnaclTranslationCacheTest::GetNexe(const std::string& key) {
-  TestNexeCallback load_cb;
-  cache_->GetNexe(key, load_cb.callback());
-  int rv;
-  scoped_refptr<net::DrainableIOBuffer> buf(load_cb.GetResult(&rv));
-  EXPECT_EQ(net::OK, rv);
-  if (buf.get() == NULL) // for some reason ASSERT macros don't work here.
-    return std::string();
-  std::string nexe(buf->data(), buf->size());
-  return nexe;
-}
-
-static const std::string test_key("1");
-static const std::string test_store_val("testnexe");
-static const int kLargeNexeSize = 8 * 1024 * 1024;
-
-TEST(PnaclTranslationCacheKeyTest, CacheKeyTest) {
-  nacl::PnaclCacheInfo info;
-  info.pexe_url = GURL("http://www.google.com");
-  info.abi_version = 0;
-  info.opt_level = 0;
-  std::string test_time("Wed, 15 Nov 1995 06:25:24 GMT");
-  base::Time::FromString(test_time.c_str(), &info.last_modified);
-  // Basic check for URL and time components
-  EXPECT_EQ("ABI:0;opt:0;URL:http://www.google.com/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  // Check that query portion of URL is not stripped
-  info.pexe_url = GURL("http://www.google.com/?foo=bar");
-  EXPECT_EQ("ABI:0;opt:0;URL:http://www.google.com/?foo=bar;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  // Check that username, password, and normal port are stripped
-  info.pexe_url = GURL("https://user:host@www.google.com:443/");
-  EXPECT_EQ("ABI:0;opt:0;URL:https://www.google.com/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  // Check that unusual port is not stripped but ref is stripped
-  info.pexe_url = GURL("https://www.google.com:444/#foo");
-  EXPECT_EQ("ABI:0;opt:0;URL:https://www.google.com:444/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  // Check chrome-extesnsion scheme
-  info.pexe_url = GURL("chrome-extension://ljacajndfccfgnfohlgkdphmbnpkjflk/");
-  EXPECT_EQ("ABI:0;opt:0;"
-            "URL:chrome-extension://ljacajndfccfgnfohlgkdphmbnpkjflk/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  // Check that ABI version, opt level, and etag are in the key
-  info.pexe_url = GURL("http://www.google.com/");
-  info.abi_version = 2;
-  EXPECT_EQ("ABI:2;opt:0;URL:http://www.google.com/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  info.opt_level = 2;
-  EXPECT_EQ("ABI:2;opt:2;URL:http://www.google.com/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:",
-            PnaclTranslationCache::GetKey(info));
-  info.etag = std::string("etag");
-  EXPECT_EQ("ABI:2;opt:2;URL:http://www.google.com/;"
-            "modified:1995:11:15:6:25:24:0:UTC;etag:etag",
-            PnaclTranslationCache::GetKey(info));
-
-  // Check for all the time components, and null time
-  info.last_modified = base::Time();
-  EXPECT_EQ("ABI:2;opt:2;URL:http://www.google.com/;"
-            "modified:0:0:0:0:0:0:0:UTC;etag:etag",
-            PnaclTranslationCache::GetKey(info));
-  test_time.assign("Fri, 29 Feb 2008 13:04:12 GMT");
-  base::Time::FromString(test_time.c_str(), &info.last_modified);
-  EXPECT_EQ("ABI:2;opt:2;URL:http://www.google.com/;"
-            "modified:2008:2:29:13:4:12:0:UTC;etag:etag",
-            PnaclTranslationCache::GetKey(info));
-}
-
-TEST_F(PnaclTranslationCacheTest, StoreSmallInMem) {
-  // Test that a single store puts something in the mem backend
-  InitBackend(true);
-  StoreNexe(test_key, test_store_val);
-  EXPECT_EQ(1, cache_->Size());
-}
-
-TEST_F(PnaclTranslationCacheTest, StoreSmallOnDisk) {
-  // Test that a single store puts something in the disk backend
-  InitBackend(false);
-  StoreNexe(test_key, test_store_val);
-  EXPECT_EQ(1, cache_->Size());
-}
-
-TEST_F(PnaclTranslationCacheTest, StoreLargeOnDisk) {
-  // Test a value too large(?) for a single I/O operation
-  InitBackend(false);
-  const std::string large_buffer(kLargeNexeSize, 'a');
-  StoreNexe(test_key, large_buffer);
-  EXPECT_EQ(1, cache_->Size());
-}
-
-TEST_F(PnaclTranslationCacheTest, InMemSizeLimit) {
-  InitBackend(true);
-  scoped_refptr<net::DrainableIOBuffer> large_buffer(new net::DrainableIOBuffer(
-      new net::StringIOBuffer(std::string(kMaxMemCacheSize + 1, 'a')),
-      kMaxMemCacheSize + 1));
-  net::TestCompletionCallback store_cb;
-  cache_->StoreNexe(test_key, large_buffer, store_cb.callback());
-  EXPECT_EQ(net::ERR_FAILED, store_cb.GetResult(net::ERR_IO_PENDING));
-  base::RunLoop().RunUntilIdle();  // Ensure the entry is closed.
-  EXPECT_EQ(0, cache_->Size());
-}
-
-TEST_F(PnaclTranslationCacheTest, GetOneInMem) {
-  InitBackend(true);
-  StoreNexe(test_key, test_store_val);
-  EXPECT_EQ(1, cache_->Size());
-  EXPECT_EQ(0, GetNexe(test_key).compare(test_store_val));
-}
-
-TEST_F(PnaclTranslationCacheTest, GetOneOnDisk) {
-  InitBackend(false);
-  StoreNexe(test_key, test_store_val);
-  EXPECT_EQ(1, cache_->Size());
-  EXPECT_EQ(0, GetNexe(test_key).compare(test_store_val));
-}
-
-TEST_F(PnaclTranslationCacheTest, GetLargeOnDisk) {
-  InitBackend(false);
-  const std::string large_buffer(kLargeNexeSize, 'a');
-  StoreNexe(test_key, large_buffer);
-  EXPECT_EQ(1, cache_->Size());
-  EXPECT_EQ(0, GetNexe(test_key).compare(large_buffer));
-}
-
-TEST_F(PnaclTranslationCacheTest, StoreTwice) {
-  // Test that storing twice with the same key overwrites
-  InitBackend(true);
-  StoreNexe(test_key, test_store_val);
-  StoreNexe(test_key, test_store_val + "aaa");
-  EXPECT_EQ(1, cache_->Size());
-  EXPECT_EQ(0, GetNexe(test_key).compare(test_store_val + "aaa"));
-}
-
-TEST_F(PnaclTranslationCacheTest, StoreTwo) {
-  InitBackend(true);
-  StoreNexe(test_key, test_store_val);
-  StoreNexe(test_key + "a", test_store_val + "aaa");
-  EXPECT_EQ(2, cache_->Size());
-  EXPECT_EQ(0, GetNexe(test_key).compare(test_store_val));
-  EXPECT_EQ(0, GetNexe(test_key + "a").compare(test_store_val + "aaa"));
-}
-
-TEST_F(PnaclTranslationCacheTest, GetMiss) {
-  InitBackend(true);
-  StoreNexe(test_key, test_store_val);
-  TestNexeCallback load_cb;
-  std::string nexe;
-  cache_->GetNexe(test_key + "a", load_cb.callback());
-  int rv;
-  scoped_refptr<net::DrainableIOBuffer> buf(load_cb.GetResult(&rv));
-  EXPECT_EQ(net::ERR_FAILED, rv);
-}
-
-}  // namespace pnacl
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 3c6259f..c9a4a56 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -2847,8 +2847,6 @@
             'browser/nacl_host/nacl_process_host.h',
             'browser/nacl_host/pnacl_host.cc',
             'browser/nacl_host/pnacl_host.h',
-            'browser/nacl_host/pnacl_translation_cache.cc',
-            'browser/nacl_host/pnacl_translation_cache.h',
             '../components/nacl/common/nacl_debug_exception_handler_win.cc',
             '../components/nacl/common/nacl_debug_exception_handler_win.h',
           ],
diff --git a/chrome/chrome_common.gypi b/chrome/chrome_common.gypi
index 0530a8d..10c8b85 100644
--- a/chrome/chrome_common.gypi
+++ b/chrome/chrome_common.gypi
@@ -401,8 +401,6 @@
         '../components/nacl/common/nacl_host_messages.h',
         '../components/nacl/common/nacl_process_type.h',
         '../components/nacl/common/nacl_sandbox_type_mac.h',
-        '../components/nacl/common/pnacl_types.cc',
-        '../components/nacl/common/pnacl_types.h',
       ],
       'conditions': [
         ['enable_extensions==1', {
diff --git a/chrome/chrome_tests_unit.gypi b/chrome/chrome_tests_unit.gypi
index e59e817..a31aa97 100644
--- a/chrome/chrome_tests_unit.gypi
+++ b/chrome/chrome_tests_unit.gypi
@@ -1036,7 +1036,6 @@
         'browser/metrics/variations/variations_request_scheduler_unittest.cc',
         'browser/nacl_host/nacl_file_host_unittest.cc',
         'browser/nacl_host/nacl_process_host_unittest.cc',
-        'browser/nacl_host/pnacl_translation_cache_unittest.cc',
         'browser/nacl_host/pnacl_host_unittest.cc',
         'browser/net/chrome_fraudulent_certificate_reporter_unittest.cc',
         'browser/net/chrome_network_data_saving_metrics_unittest.cc',
@@ -2126,7 +2125,6 @@
             'browser/nacl_host/nacl_file_host_unittest.cc',
             'browser/nacl_host/nacl_process_host_unittest.cc',
             'browser/nacl_host/pnacl_host_unittest.cc',
-            'browser/nacl_host/pnacl_translation_cache_unittest.cc',
             # TODO(yael): Move to //components/components_tests.gypi once
             # nacl_defines is moved out of chrome.gyp into a common place.
             '../components/nacl/loader/nacl_ipc_adapter_unittest.cc',