Add a command line switch to allow setting the max size...

chrome/browser/profile.cc

 // Copyright (c) 2006-2008 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/profile.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 29 matching lines @@
 #include "chrome/common/net/cookie_monster_sqlite.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "grit/locale_settings.h"
 #include "net/base/force_tls_state.h"
 
 using base::Time;
 using base::TimeDelta;
 
+namespace {
+
 // Delay, in milliseconds, before we explicitly create the SessionService.
 static const int kCreateSessionServiceDelayMS = 500;
 
+enum ContextType {
+  kNormalContext,
+  kMediaContext
+};
+
+// Gets the cache parameters from the command line. |type| is the type of
+// request context that we need, |cache_path| will be set to the user provided
+// path, or will not be touched if there is not an argument. |max_size| will
+// be the user provided value or zero by default.
+void GetCacheParameters(ContextType type, FilePath* cache_path,
+                        int* max_size) {
+  DCHECK(cache_path);
+  DCHECK(max_size);
+
+  // Override the cache location if specified by the user.
+  std::wstring user_path(CommandLine::ForCurrentProcess()->GetSwitchValue(
+                             switches::kDiskCacheDir));
+
+  if (!user_path.empty()) {
+    *cache_path = FilePath::FromWStringHack(user_path);
+  }
+
+  const wchar_t* arg = kNormalContext == type ? switches::kDiskCacheSize :
+                                                switches::kMediaCacheSize;
+  std::string value =
+      WideToASCII(CommandLine::ForCurrentProcess()->GetSwitchValue(arg));
+
+  // By default we let the cache determine the right size.
+  *max_size = 0;
+  if (!StringToInt(value, max_size)) {
+    *max_size = 0;
+  } else if (max_size < 0) {
+    *max_size = 0;
+  }
+}
+
+}  // namespace
+
 // A pointer to the request context for the default profile.  See comments on
 // Profile::GetDefaultRequestContext.
 URLRequestContext* Profile::default_request_context_;
 
 static void CleanupRequestContext(ChromeURLRequestContext* context) {
   if (context) {
     context->CleanupOnUIThread();
 
     // Clean up request context on IO thread.
     g_browser_process->io_thread()->message_loop()->ReleaseSoon(FROM_HERE,
@@ skipping 633 matching lines @@
   FilePath pref_file_path = path_;
   pref_file_path = pref_file_path.Append(chrome::kPreferencesFilename);
   return pref_file_path;
 }
 
 URLRequestContext* ProfileImpl::GetRequestContext() {
   if (!request_context_) {
     FilePath cookie_path = GetPath();
     cookie_path = cookie_path.Append(chrome::kCookieFilename);
     FilePath cache_path = GetPath();
-
-    // Override the cache location if specified by the user.
-    const std::wstring user_cache_dir(
-        CommandLine::ForCurrentProcess()->GetSwitchValue(
-            switches::kDiskCacheDir));
-    if (!user_cache_dir.empty()) {
-      cache_path = FilePath::FromWStringHack(user_cache_dir);
-    }
+    int max_size;
+    GetCacheParameters(kNormalContext, &cache_path, &max_size);
 
     cache_path = cache_path.Append(chrome::kCacheDirname);
     request_context_ = ChromeURLRequestContext::CreateOriginal(
-        this, cookie_path, cache_path);
+        this, cookie_path, cache_path, max_size);
     request_context_->AddRef();
 
     // The first request context is always a normal (non-OTR) request context.
     // Even when Chromium is started in OTR mode, a normal profile is always
     // created first.
     if (!default_request_context_) {
       default_request_context_ = request_context_;
       NotificationService::current()->Notify(
           NotificationType::DEFAULT_REQUEST_CONTEXT_AVAILABLE,
           NotificationService::AllSources(), NotificationService::NoDetails());
     }
 
     DCHECK(request_context_->cookie_store());
   }
 
   return request_context_;
 }
 
 URLRequestContext* ProfileImpl::GetRequestContextForMedia() {
   if (!media_request_context_) {
     FilePath cache_path = GetPath();
-
-    // Override the cache location if specified by the user.
-    const std::wstring user_cache_dir(
-        CommandLine::ForCurrentProcess()->GetSwitchValue(
-            switches::kDiskCacheDir));
-    if (!user_cache_dir.empty()) {
-      cache_path = FilePath::FromWStringHack(user_cache_dir);
-    }
+    int max_size;
+    GetCacheParameters(kMediaContext, &cache_path, &max_size);
 
     cache_path = cache_path.Append(chrome::kMediaCacheDirname);
     media_request_context_ = ChromeURLRequestContext::CreateOriginalForMedia(
-        this, cache_path);
+        this, cache_path, max_size);
     media_request_context_->AddRef();
 
     DCHECK(media_request_context_->cookie_store());
   }
 
   return media_request_context_;
 }
 
 URLRequestContext* ProfileImpl::GetRequestContextForExtensions() {
   if (!extensions_request_context_) {
@@ skipping 335 matching lines @@
 
 void ProfileImpl::StopCreateSessionServiceTimer() {
   create_session_service_timer_.Stop();
 }
 
 #ifdef CHROME_PERSONALIZATION
 ProfilePersonalization* ProfileImpl::GetProfilePersonalization() {
   return personalization_.get();
 }
 #endif