Initialize the simple cache backend at runtime.

net/disk_cache/disk_cache_test_base.h

Index: net/disk_cache/disk_cache_test_base.h
===================================================================
--- net/disk_cache/disk_cache_test_base.h	(revision 190930)
+++ net/disk_cache/disk_cache_test_base.h	(working copy)
@@ -59,7 +59,10 @@
   DiskCacheTestWithCache();
   virtual ~DiskCacheTestWithCache();
 
+  void CreateBackendAsModeSuggests(uint32 flags, base::Thread* thread);

[rvargas (doing something else), 2013/03/28 03:12:45]

nit: CreateBackend() ? (does it make sense to CreateBackendIgnoringTheMode ?)

[pasko-google - do not use, 2013/03/28 21:41:42]

I made something that is easier to grep through sources. 

[rvargas (doing something else), 2013/03/28 22:30:21]

hmmm... I really don't consider the uniqueness of names for search to be a
quality of the code. The second part of the name doesn't make any sense to me:
yes, it is something that the code does, but it doesn't provide any information
at all because it is something that the code should be doing. It adds as much
value as CreateBackendAndTryHardNotToFail, and that would also be unique for a
search, but it hurts readability of the code because it is noise that makes me
wonder if there's something funky going on with the code.

I think it is more important for the code to read naturally, without extraneous
decorations.

[pasko-google - do not use, 2013/03/29 02:20:26]

Ok, does CreateCacheBackendForTesting sound better? I still like the uniqueness,
even if it adds clutter in the name, it gets much easier to navigate the code. I
often read the code in non-linear ways in vim with exuberant-ctags (yeah, I
know, sounds ancient), so the 10 variants of CreateBackend are bothering in
similar ways as multiple wrapper layers do. Am I not cooking it right?
I have this argument about code spanning across multiple files, where it is
easier to read by  jumping across files by exact named pointers rather than very
common names. There are obviously very common names like Run() which I did not
learn how to deal with.

[rvargas (doing something else), 2013/03/29 06:49:22]

You can go with something that doesn't say "CreateBackend" if you are worried
about that being mixed with another method. I'm not that happy either with
"ForTesting" here because this is not a production class (where "ForTesting" has
a very specific meaning)... and this class is already test specific...
everything it does is for tests.
I thought we were going to have only one version (after removing the factories
from all backends) :)

This is interesting because we have almost opposite use cases. I'm either
following the code, in which case something like "go to declaration" is what I
would use (and the name doesn't matter), or all I know is that I want to go to a
function that does foo and lives in a given file, in which case I go to that
file and start looking for the name (and this is a more common use case). The
problem is that having unique names doesn't work that well in that case, and I
much rather have the same functionality methods have the same names because then
it is easier to know or remember what to look for: I'm at foo in file x, now
look for foo on file y and that's it, instead of trying to remember a synonym of
"foo" because file y doesn't use the same name but rather something that is
almost like it.

I thought you were talking about doing global searches for foo and having 10
pages of results to wade through to get to the one that you were after... and I
sympathize in that case but I much rather have too many results and have to
filter for path, or see less context for each result than having no result
because I cannot remember the proper incantation used on the class that I'm
after. And note that varying post-fixes doesn't help because it's helpful to
look for methods by including the open parenthesis at the end of the name.

[pasko-google - do not use, 2013/03/29 20:05:12]

renamed to DiskCacheTestWithCache::CreateBackend

[pasko-google - do not use, 2013/03/29 20:05:12]

Interesting. That's the difference, I normally ignore file names, I jump to
function declaration or grep for its callsites. Every time there is a different
function with the same name, it adds a mental barrier, following the code gets
down from a fraction of a second to dozens of seconds or even minutes.

I only notice file names occasionally. The code is important, filenames are
secondary. As far as I understand these days the main reason for separating code
into multiple files is parallel build.

+
   void InitCache();
+  void InitDefaultCacheViaCreator();

[rvargas (doing something else), 2013/03/28 03:12:45]

nit: InitCacheViaCreator ? InitDefaultCache ?

(probably #2 given that it should not really use the creator :) )

[pasko-google - do not use, 2013/03/28 21:41:42]

The whole point of this function is to test via Creator. I'll remove it if we
can do the same with CreateCacheBackend(). The word Default suggests that we
cannot control which backend to create, it chooses the platform's default.

[rvargas (doing something else), 2013/03/28 22:30:21]

I don't agree there. The point is to use the regular interface that clients use.
And we cannot control it beyond what a regular caller should be able to control.
We agree that  the word default is right, no?

[pasko-google - do not use, 2013/03/29 02:20:26]

I agree that we should test the regular interface when possible. And very soon
the CreateCacheBackend may become not possible to use on all platforms in the
same way. Disabling tests for those platforms is probably your suggestion. That
would certainly work.
I did not understand this last sentence :)

OK, in the next CL I am trying to use the official CreateCacheBackend(), to
replace all calls to InitDefaultCacheViaCreator().

[rvargas (doing something else), 2013/03/29 06:49:22]

I meant the point of this method, not the point in general... in general, we are
moving almost all tests to diverge from testing the interface... to the point of
eliminating UseImplementation() on this CL, and making it the default.

Use of this method should be very uncommon.
yeah... I was just saying that I got lost because we ended up talking about the
meaning of the word "default" as being part of the name and I thought you were
fine with it (as I am). Let's move on :)

   void SimulateCrash();
   void SetTestMode();
 
@@ -67,9 +70,8 @@
     memory_only_ = true;
   }
 
-  // Use the implementation directly instead of the factory provided object.
-  void SetDirectMode() {
-    implementation_ = true;
+  void SetSimpleCacheMode() {
+    simple_cache_mode_ = true;
   }
 
   void SetMask(uint32 mask) {
@@ -148,7 +150,7 @@
   int size_;
   net::CacheType type_;
   bool memory_only_;
-  bool implementation_;
+  bool simple_cache_mode_;
   bool force_creation_;
   bool new_eviction_;
   bool first_cleanup_;
@@ -160,7 +162,6 @@
  private:
   void InitMemoryCache();
   void InitDiskCache();
-  void InitDiskCacheImpl();
 
   base::Thread cache_thread_;
   DISALLOW_COPY_AND_ASSIGN(DiskCacheTestWithCache);