Disable caching "Chrome Hotword Shared Module" extension (temporary).

chrome/browser/extensions/updater/extension_cache_impl.cc

 // 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 "chrome/browser/extensions/updater/extension_cache_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/updater/local_extension_cache.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 namespace extensions {
 namespace {
 
+// Temporary workaround for M41, this extension should not be cached.
+// TODO: Implement id/hash-based map instead of id/version.

[Dmitry Polukhin, 2015/01/15 09:40:38]

Please use TODO(ginkage)... as in style guide and move it to AllowCaching.

+const char kBlacklistedExt[] = "lccekmodgklaepjeofjdjpbminllajkg";

[Dmitry Polukhin, 2015/01/15 09:40:38]

This constant already exists kHotwordSharedModuleId please use it instead.

+
 #if defined(OS_CHROMEOS)
 const char kLocalCacheDir[] = "/var/cache/external_cache";
 #else
 #error Please define kLocalCacheDir suitable for target OS
 #endif// Directory where the extensions are cached.
 
 // Maximum size of local cache on disk.
 size_t kMaxCacheSize = 100 * 1024 * 1024;
 
 // Maximum age of unused extensions in cache.
@@ skipping 31 matching lines @@
 }
 
 void ExtensionCacheImpl::Shutdown(const base::Closure& callback) {
   if (cache_)
     cache_->Shutdown(callback);
   else
     callback.Run();
 }
 
 void ExtensionCacheImpl::AllowCaching(const std::string& id) {
+  if (id == kBlacklistedExt)
+    return;
   allowed_extensions_.insert(id);
 }
 
 bool ExtensionCacheImpl::GetExtension(const std::string& id,
                                       base::FilePath* file_path,
                                       std::string* version) {
-  if (cache_)
+  if (cache_ && id != kBlacklistedExt)

[Dmitry Polukhin, 2015/01/15 09:40:38]

I would check if caching allowed like this 'ContainsKey(allowed_extensions_,
id)' or even make this check separate function to call it from PutExtension and
GetExtension.

[ginkage, 2015/01/15 15:02:24]

I'm not really sure: I've added this check for cases when the extension is
already in the cache, but we should not use it (like, after a system upgrade).
Otherwise, AllowCaching check is sufficient.

[Dmitry Polukhin, 2015/01/15 15:07:48]

Yes, check in GetExtension required to recover if wrong variant is already in
the cache. Repeating check in GetExtension should generalize cases like when
extension shouldn't be cache and used from cache in any case.

     return cache_->GetExtension(id, file_path, version);
   else
     return false;
 }
 
 void ExtensionCacheImpl::PutExtension(const std::string& id,
                                       const base::FilePath& file_path,
                                       const std::string& version,
                                       const PutExtensionCallback& callback) {
   if (cache_ && ContainsKey(allowed_extensions_, id))
@@ skipping 34 matching lines @@
       cache_->RemoveExtension(installer->expected_id());
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace extensions