Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/visitedlink_master.h

 // 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.
 
 #ifndef CHROME_BROWSER_VISITEDLINK_MASTER_H__
 #define CHROME_BROWSER_VISITEDLINK_MASTER_H__
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/ref_counted.h"
 #include "base/shared_memory.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/common/visitedlink_common.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 class GURL;
 class MessageLoop;
 class Profile;
 
-namespace base {
-class Thread;
-}  // namespace base
-
 // Controls the link coloring database. The master controls all writing to the
 // database as well as disk I/O. There should be only one master.
 //
-// This class will optionally defer writing operations to another thread. This
-// means that after class destruction, the file may still be open since
-// operations are pending on another thread.
+// This class will defer writing operations to the file thread. This means that
+// class destruction, the file may still be open since operations are pending on
+// another thread.
 class VisitedLinkMaster : public VisitedLinkCommon {
  public:
   // Listens to the link coloring database events. The master is given this
   // event as a constructor argument and dispatches events using it.
   class Listener {
    public:
     virtual ~Listener() {}
 
     // Called when link coloring database has been created or replaced. The
     // argument is the new table handle.
     virtual void NewTable(base::SharedMemory*) = 0;
 
     // Called when new link has been added. The argument is the fingerprint
     // (hash) of the link.
     virtual void Add(Fingerprint fingerprint) = 0;
 
     // Called when link coloring state has been reset. This may occur when
     // entire or parts of history were deleted.
     virtual void Reset() = 0;
   };
 
-  // The |file_thread| may be NULL, in which case write operations will be
-  // synchronous.
   // The |listener| may not be NULL.
-  VisitedLinkMaster(base::Thread* file_thread,
-                    Listener* listener,
-                    Profile* profile);
+  VisitedLinkMaster(Listener* listener, Profile* profile);
 
   // In unit test mode, we allow the caller to optionally specify the database
   // filename so that it can be run from a unit test. The directory where this
   // file resides must exist in this mode. You can also specify the default
   // table size to test table resizing. If this parameter is 0, we will use the
   // defaults.
   //
   // In the unit test mode, we also allow the caller to provide a history
   // service pointer (the history service can't be fetched from the browser
   // process when we're in unit test mode). This can be NULL to try to access
   // the main version, which will probably fail (which can be good for testing
   // this failure mode).
   //
   // When |suppress_rebuild| is set, we'll not attempt to load data from
   // history if the file can't be loaded. This should generally be set for
   // testing except when you want to test the rebuild process explicitly.
-  VisitedLinkMaster(base::Thread* file_thread,
-                    Listener* listener,
+  VisitedLinkMaster(Listener* listener,
                     HistoryService* history_service,
                     bool suppress_rebuild,
                     const FilePath& filename,
                     int32 default_table_size);
   virtual ~VisitedLinkMaster();
 
   // Must be called immediately after object creation. Nothing else will work
   // until this is called. Returns true on success, false means that this
   // object won't work.
   bool Init();
@@ skipping 70 matching lines @@
 
   // When creating a fresh new table, we use this many entries.
   static const unsigned kDefaultTableSize;
 
   // When the user is deleting a boatload of URLs, we don't really want to do
   // individual writes for each of them. When the count exceeds this threshold,
   // we will write the whole table to disk at once instead of individual items.
   static const size_t kBigDeleteThreshold;
 
   // Backend for the constructors initializing the members.
-  void InitMembers(base::Thread* file_thread,
-                   Listener* listener,
-                   Profile* profile);
+  void InitMembers(Listener* listener, Profile* profile);
 
   // If a rebuild is in progress, we save the URL in the temporary list.
   // Otherwise, we add this to the table. Returns the index of the
   // inserted fingerprint or null_hash_ on failure.
   Hash TryToAddURL(const GURL& url);
 
   // File I/O functions
   // ------------------
 
   // Writes the entire table to disk, returning true on success. It will leave
@@ skipping 134 matching lines @@
 
 #ifndef NDEBUG
   // Indicates whether any asynchronous operation has ever been completed.
   // We do some synchronous reads that require that no asynchronous operations
   // are pending, yet we don't track whether they have been completed. This
   // flag is a sanity check that these reads only happen before any
   // asynchronous writes have been fired.
   bool posted_asynchronous_operation_;
 #endif
 
-  // The thread where we do write operations from to avoid synchronous I/O on
-  // the main thread. This may be NULL, which indicates synchronous I/O.
-  MessageLoop* file_thread_;
-
   // Reference to the user profile that this object belongs to
   // (it knows the path to where the data is stored)
   Profile* profile_;
 
   // When non-NULL, indicates we are in database rebuild mode and points to
   // the class collecting fingerprint information from the history system.
   // The pointer is owned by this class, but it must remain valid while the
   // history query is running. We must only delete it when the query is done.
   scoped_refptr<TableBuilder> table_builder_;
 
@@ skipping 59 matching lines @@
   int32 used_count = 0;
   for (int32 i = 0; i < table_length_; i++) {
     if (hash_table_[i])
       used_count++;
   }
   DCHECK_EQ(used_count, used_items_);
 }
 #endif
 
 #endif // CHROME_BROWSER_VISITEDLINK_MASTER_H__