Convert visitedlink to use mojo.

components/visitedlink/browser/visitedlink_master.h

 // Copyright (c) 2012 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 COMPONENTS_VISITEDLINK_BROWSER_VISITEDLINK_MASTER_H_
 #define COMPONENTS_VISITEDLINK_BROWSER_VISITEDLINK_MASTER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "components/visitedlink/common/visitedlink_common.h"
+#include "mojo/public/cpp/system/buffer.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #if defined(UNIT_TEST) || defined(PERF_TEST) || !defined(NDEBUG)
 #include "base/logging.h"
 #endif
 
 class GURL;
@@ skipping 15 matching lines @@
 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;
+    virtual void NewTable(mojo::SharedBufferHandle table) = 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. Also this may occur when
     // the table was rebuilt or loaded. The salt is stored in the database file.
     // As a result the salt will change after loading the table from the
     // database file. In this case we use |invalidate_hashes| to inform that
     // all cached visitedlink hashes need to be recalculated.
     virtual void Reset(bool invalidate_hashes) = 0;
   };
 
+  // |listener| may be non-null to inject a listener for tests. If non-null a
+  // default Listener will be used.
   VisitedLinkMaster(content::BrowserContext* browser_context,
                     VisitedLinkDelegate* delegate,
-                    bool persist_to_disk);
+                    bool persist_to_disk,
+                    std::unique_ptr<Listener> listener = nullptr);

[dcheng, 2016/09/20 22:29:27]

Nit: I think it's slightly better to just have SetListenerForTest(). That way,
we minimize the amount of test-only code in the Chrome binary. It means we
needlessly allocate an object in a test, but if we immediately replace it, that
should be fine, right?

(Similar thoughts about the timer override in VisitedLinkUpdater)

[Sam McNally, 2016/09/21 02:38:14]

Done.

 
   // 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(Listener* listener,
                     VisitedLinkDelegate* delegate,
                     bool persist_to_disk,
                     bool suppress_rebuild,
                     const base::FilePath& filename,
                     int32_t default_table_size);
   ~VisitedLinkMaster() override;
 
   // 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();
 
-  base::SharedMemory* shared_memory() { return shared_memory_; }
+  const mojo::SharedBufferHandle& shared_memory() {
+    return shared_memory_.get();
+  }
 
   // Adds a URL to the table.
   void AddURL(const GURL& url);
 
   // Adds a set of URLs to the table.
   void AddURLs(const std::vector<GURL>& urls);
 
   // See DeleteURLs.
   class URLIterator {
    public:
@@ skipping 194 matching lines @@
   bool InitFromScratch(bool suppress_rebuild);
 
   // Allocates the Fingerprint structure and length. Structure is filled with 0s
   // and shared header with salt and used_items_ is set to 0.
   bool CreateURLTable(int32_t num_entries);
 
   // Allocates the Fingerprint structure and length. Returns true on success.
   // Structure is filled with 0s and shared header with salt. The result of
   // allocation is saved into |shared_memory| and |hash_table| points to the
   // beginning of Fingerprint table in |shared_memory|.
-  static bool CreateApartURLTable(
-      int32_t num_entries,
-      const uint8_t salt[LINK_SALT_LENGTH],
-      std::unique_ptr<base::SharedMemory>* shared_memory,
-      VisitedLinkCommon::Fingerprint** hash_table);
+  static bool CreateApartURLTable(int32_t num_entries,
+                                  const uint8_t salt[LINK_SALT_LENGTH],
+                                  mojo::ScopedSharedBufferHandle* shared_memory,
+                                  mojo::ScopedSharedBufferMapping* hash_table);
 
   // A wrapper for CreateURLTable, this will allocate a new table, initialized
   // to empty. The caller is responsible for saving the shared memory pointer
   // and handles before this call (they will be replaced with new ones) and
   // releasing them later. This is designed for callers that make a new table
   // and then copy values from the old table to the new one, then release the
   // old table.
   //
   // Returns true on success. On failure, the old table will be restored. The
   // caller should not attemp to release the pointer/handle in this case.
@@ skipping 45 matching lines @@
     if (hash >= table_length_ - 1)
       return 0;  // Wrap around.
     return hash + 1;
   }
   inline Hash DecrementHash(Hash hash) {
     if (hash <= 0)
       return table_length_ - 1;  // Wrap around.
     return hash - 1;
   }
 
+  // Returns a pointer to the start of the hash table, given the mapping
+  // containing the hash table.
+  static Fingerprint* GetHashTableFromMapping(
+      const mojo::ScopedSharedBufferMapping& hash_table_mapping);
+
   // Reference to the browser context that this object belongs to
   // (it knows the path to where the data is stored)
   content::BrowserContext* browser_context_;
 
   // Client owns the delegate and is responsible for it being valid through
   // the life time this VisitedLinkMaster.
   VisitedLinkDelegate* delegate_;
 
   // VisitedLinkEventListener to handle incoming events.
   std::unique_ptr<Listener> listener_;
@@ skipping 25 matching lines @@
   // guaranteed to be executed after the opening.
   // The class owns both the |file_| pointer and the pointer pointed
   // by |*file_|.
   FILE** file_;
 
   // If true, will try to persist the hash table to disk. Will rebuild from
   // VisitedLinkDelegate::RebuildTable if there are disk corruptions.
   bool persist_to_disk_;
 
   // Shared memory consists of a SharedHeader followed by the table.
-  base::SharedMemory *shared_memory_;
+  mojo::ScopedSharedBufferHandle shared_memory_;
+
+  // A mapping of the table including the SharedHeader.
+  // GetHashTableFromMapping() can be used to obtain a pointer to the hash table
+  // contained in this mapping.
+  mojo::ScopedSharedBufferMapping hash_table_mapping_;
 
   // When we generate new tables, we increment the serial number of the
   // shared memory object.
   int32_t shared_memory_serial_;
 
   // Number of non-empty items in the table, used to compute fullness.
   int32_t used_items_;
 
   // We set this to true to avoid writing to the database file.
   bool table_is_loading_from_file_;
@@ skipping 36 matching lines @@
     if (hash_table_[i])
       used_count++;
   }
   DCHECK_EQ(used_count, used_items_);
 }
 #endif
 
 }  // namespace visitedlink
 
 #endif  // COMPONENTS_VISITEDLINK_BROWSER_VISITEDLINK_MASTER_H_