Reland: Move ExtensionCache to //extensions

This is a reland of the CL
https://codereview.chromium.org/612423003 to correct expected behavior
in some Chrome OS tests.

Because the mere act of constructing an ExtensionCacheImpl has side-
effects on the message loop state, its construction has been removed
from the ChromeExtensionsBrowserClient ctor. It is now constructed
lazily upon calling GetExtensionCache() of the same class, making it
effectively equivalent to its prior usage (construction upon first
call to ExtensionCache::GetInstance).

BUG=398671,422884
TBR=pastarmovj@chromium.org

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

Cr-Commit-Position: refs/heads/master@{#299501}

3 files changed, 140 insertions, 0 deletions

diff --git a/extensions/browser/updater/extension_cache.h b/extensions/browser/updater/extension_cache.h
new file mode 100644
index 0000000..f6bdb02
--- /dev/null
+++ b/extensions/browser/updater/extension_cache.h
@@ -0,0 +1,63 @@
+// Copyright 2014 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 EXTENSIONS_BROWSER_UPDATER_EXTENSION_CACHE_H_
+#define EXTENSIONS_BROWSER_UPDATER_EXTENSION_CACHE_H_
+
+#include <string>
+
+#include "base/callback_forward.h"
+#include "base/files/file_path.h"
+
+namespace extensions {
+
+// ExtensionCache interface that caches extensions .crx files to share them
+// between multiple users and profiles on the machine.
+class ExtensionCache {
+ public:
+  // Callback that is invoked when the file placed when PutExtension done.
+  typedef base::Callback<void(const base::FilePath& file_path,
+                              bool file_ownership_passed)> PutExtensionCallback;
+
+  ExtensionCache() {}
+  virtual ~ExtensionCache() {}
+
+  // Initialize cache in background. The |callback| is called when cache ready.
+  // Can be called multiple times. The |callback| can be called immediately if
+  // cache is ready.
+  virtual void Start(const base::Closure& callback) = 0;
+
+  // Shut down the cache. Must be called at most once on browser shutdown.
+  virtual void Shutdown(const base::Closure& callback) = 0;
+
+  // Allow caching for the extension with given |id|. User specific extensions
+  // should not be cached for privacy reasons. But default apps including policy
+  // configured can be cached. Can be called before Init.
+  virtual void AllowCaching(const std::string& id) = 0;
+
+  // If extension with |id| exists in the cache, returns |true|, |file_path| and
+  // |version| for the extension. Extension will be marked as used with current
+  // timestamp.
+  virtual bool GetExtension(const std::string& id,
+                            base::FilePath* file_path,
+                            std::string* version) = 0;
+
+  // Put extension with |id| and |version| into local cache. Older version in
+  // the cache will removed be on next run so it can be safely used. Extension
+  // will be marked as used with current timestamp. The file will be available
+  // via GetExtension when |callback| is called. Original |file_path| won't be
+  // deleted from the disk. There is no guarantee that |callback| will be
+  // called.
+  virtual void PutExtension(const std::string& id,
+                            const base::FilePath& file_path,
+                            const std::string& version,
+                            const PutExtensionCallback& callback) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ExtensionCache);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_UPDATER_EXTENSION_CACHE_H_
diff --git a/extensions/browser/updater/null_extension_cache.cc b/extensions/browser/updater/null_extension_cache.cc
new file mode 100644
index 0000000..3241d20
--- /dev/null
+++ b/extensions/browser/updater/null_extension_cache.cc
@@ -0,0 +1,41 @@
+// Copyright 2014 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 "extensions/browser/updater/null_extension_cache.h"
+
+#include "base/callback.h"
+
+namespace extensions {
+
+NullExtensionCache::NullExtensionCache() {
+}
+
+NullExtensionCache::~NullExtensionCache() {
+}
+
+void NullExtensionCache::Start(const base::Closure& callback) {
+  callback.Run();
+}
+
+void NullExtensionCache::Shutdown(const base::Closure& callback) {
+  callback.Run();
+}
+
+void NullExtensionCache::AllowCaching(const std::string& id) {
+}
+
+bool NullExtensionCache::GetExtension(const std::string& id,
+                                      base::FilePath* file_path,
+                                      std::string* version) {
+  return false;
+}
+
+void NullExtensionCache::PutExtension(const std::string& id,
+                                      const base::FilePath& file_path,
+                                      const std::string& version,
+                                      const PutExtensionCallback& callback) {
+  callback.Run(file_path, true);
+}
+
+}  // namespace extensions
diff --git a/extensions/browser/updater/null_extension_cache.h b/extensions/browser/updater/null_extension_cache.h
new file mode 100644
index 0000000..c4c9a1b
--- /dev/null
+++ b/extensions/browser/updater/null_extension_cache.h
@@ -0,0 +1,36 @@
+// Copyright 2014 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 EXTENSIONS_BROWSER_UPDATER_NULL_EXTENSION_CACHE_H_
+#define EXTENSIONS_BROWSER_UPDATER_NULL_EXTENSION_CACHE_H_
+
+#include "extensions/browser/updater/extension_cache.h"
+
+namespace extensions {
+
+// Implements a pass-thru (i.e. do-nothing) ExtensionCache.
+class NullExtensionCache : public ExtensionCache {
+ public:
+  NullExtensionCache();
+  virtual ~NullExtensionCache();
+
+  // ExtensionCache implementation.
+  virtual void Start(const base::Closure& callback) override;
+  virtual void Shutdown(const base::Closure& callback) override;
+  virtual void AllowCaching(const std::string& id) override;
+  virtual bool GetExtension(const std::string& id,
+                            base::FilePath* file_path,
+                            std::string* version) override;
+  virtual void PutExtension(const std::string& id,
+                            const base::FilePath& file_path,
+                            const std::string& version,
+                            const PutExtensionCallback& callback) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NullExtensionCache);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_UPDATER_NULL_EXTENSION_CACHE_H_