Remove void** from disk_cache interface.

net/disk_cache/disk_cache.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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://dev.chromium.org/developers/design-documents/network-stack/disk-cache
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H_
 #define NET_DISK_CACHE_DISK_CACHE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 
 namespace base {
 class FilePath;
 class SingleThreadTaskRunner;
 }
 
@@ skipping 29 matching lines @@
     int max_bytes,
     bool force,
     const scoped_refptr<base::SingleThreadTaskRunner>& thread,
     net::NetLog* net_log,
     scoped_ptr<Backend>* backend,
     const net::CompletionCallback& callback);
 
 // The root interface for a disk cache instance.
 class NET_EXPORT Backend {
  public:
+  class EnumerationState {
+   public:
+    virtual ~EnumerationState() = 0;
+  };
+  typedef scoped_ptr<EnumerationState> Iterator;

[rvargas (doing something else), 2014/09/05 02:01:29]

I don't think we need (or want) an extra typedef to hide a scoped_ptr

[gavinp, 2014/09/11 23:57:04]

The latest upload removes the typedef.

   typedef net::CompletionCallback CompletionCallback;
 
   // If the backend is destroyed when there are operations in progress (any
   // callback that has not been invoked yet), this method cancels said
   // operations so the callbacks are not invoked, possibly leaving the work
   // half way (for instance, dooming just a few entries). Note that pending IO
   // for a given Entry (as opposed to the Backend) will still generate a
   // callback from within this method.
-  virtual ~Backend() {}
+  virtual ~Backend();
 
   // Returns the type of this cache.
   virtual net::CacheType GetCacheType() const = 0;
 
   // Returns the number of entries in the cache.
   virtual int32 GetEntryCount() const = 0;
 
   // Opens an existing entry. Upon success, |entry| holds a pointer to an Entry
   // object representing the specified disk cache entry. When the entry pointer
   // is no longer needed, its Close method should be called. The return value is
@@ skipping 32 matching lines @@
                                  base::Time end_time,
                                  const CompletionCallback& callback) = 0;
 
   // Marks all entries accessed since |initial_time| for deletion. The return
   // value is a net error code. If this method returns ERR_IO_PENDING, the
   // |callback| will be invoked when the operation completes.
   // Entries with |initial_time| <= access time are deleted.
   virtual int DoomEntriesSince(base::Time initial_time,
                                const CompletionCallback& callback) = 0;
 
-  // Enumerates the cache. Initialize |iter| to NULL before calling this method
-  // the first time. That will cause the enumeration to start at the head of
-  // the cache. For subsequent calls, pass the same |iter| pointer again without
-  // changing its value. This method returns ERR_FAILED when there are no more
-  // entries to enumerate. When the entry pointer is no longer needed, its
-  // Close method should be called. The return value is a net error code. If
-  // this method returns ERR_IO_PENDING, the |callback| will be invoked when the
-  // |next_entry| is available. The pointer to receive the |next_entry| must
-  // remain valid until the operation completes.
-  //
-  // NOTE: This method does not modify the last_used field of the entry, and
-  // therefore it does not impact the eviction ranking of the entry. However,
-  // an enumeration will go through all entries on the cache only if the cache
-  // is not modified while the enumeration is taking place. Significantly
-  // altering the entry pointed by |iter| (for example, deleting the entry) will
-  // invalidate |iter|. Performing operations on an entry that modify the entry
-  // may result in loops in the iteration, skipped entries or similar.
-  virtual int OpenNextEntry(void** iter, Entry** next_entry,
+  // Enumerates the cache. Initialize |iter| to NULL for the first call, and
+  // provide it again for subsequent calls. For each successful step of
+  // enumeration, OpenNextEntry returns OK and provides |next_entry|, which is
+  // open and should be closed by the caller. This method returns ERR_FAILED at
+  // the end of enumeration. If any entry in a cache is modified during
+  // iteration, then the result of this function is thereafter undefined.
+  virtual int OpenNextEntry(Iterator* iter, Entry** next_entry,

[rvargas (doing something else), 2014/09/05 02:01:29]

So far I'm unconvinced about the API change.

The current pattern is pretty standard: the cache returns an opaque handle to
the consumer and the consumer uses it for further enumerations until it doesn't
want to enumerate anymore. The consumer cannot do any operation directly with
that handle.

Sure, it is a C-style pattern, but it is extremely common and makes sure the
cache is in control of the iteration at all times.

What you propose opens up the caller to know, and do more with the iterator than
it should. It also poses restrictions on the implementation that I don't see
fully justified: deletion of the object is tied to the consumer[1] and cleanup
when the cache goes away may be more complicated (as now it has to make sure
that anything related to an iterator can be left behind because it gave up
ownership to the consumer, who really should not care about what is tied to the
iterator).

[1] Arguably, calling a function to say that the iterator is not needed is
basically the same as directly deleting the iterator, but there is a conceptual
difference between "I delete this because I own it, and I know what to do with
it" and "I don't know what this is and I don't need it anymore so I'll tell the
owner about it". It limits what the cache can do with it, or may force an extra
layer of isolation just for the sake of it. I still think that the second
message is the one that the API should deliver.

Another way to put it is that so far I much rather let the cache cleanup all
enumerations at destruction (and leave the caller with handles that are invalid,
but there's no cache to call), than leave a bunch of enumerators lying around
after the cache is gone.

[gavinp, 2014/09/11 23:57:04]

The existing pattern of using a void** is neither standard or extremely common
in chrome APIs. This CL removes the last instance of us advertising such an API
in net/.

A caller cannot "do more with the iterator than it should."

You say you would "rather let the cache cleanup all enumerations at
destruction." Your suggestion contradicts the current documentation of the
EndEnumeration() function "... the enumeration must be ended ...".

Happily, this change reduces the need for documentation. The APIs use of
scoped_ptr<> defines ownership and forces callers to use it safely. As a result,
a lot of confusing comment text describing a complex ownership rule is removed.
Even better, many existing tests that violated those rules now only test
documented behaviour.

On 2014/09/05 02:01:29, rvargas wrote:

                             const CompletionCallback& callback) = 0;
 
-  // Releases iter without returning the next entry. Whenever OpenNextEntry()
-  // returns true, but the caller is not interested in continuing the
-  // enumeration by calling OpenNextEntry() again, the enumeration must be
-  // ended by calling this method with iter returned by OpenNextEntry().
-  virtual void EndEnumeration(void** iter) = 0;
-
   // Return a list of cache statistics.
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) = 0;
 
   // Called whenever an external cache in the system reuses the resource
   // referred to by |key|.
   virtual void OnExternalCacheHit(const std::string& key) = 0;
 };
 
 // This interface represents an entry in the disk cache.
@@ skipping 141 matching lines @@
   // OK although another IO operation cannot be issued at this time; in this
   // case the caller should just wait for the regular callback to be invoked
   // instead of using this method to provide another callback.
   //
   // Note that CancelSparseIO may have been called on another instance of this
   // object that refers to the same physical disk entry.
   // Note: This method is deprecated.
   virtual int ReadyForSparseIO(const CompletionCallback& callback) = 0;
 
  protected:
-  virtual ~Entry() {}
+  virtual ~Entry();
 };
 
 struct EntryDeleter {
   void operator()(Entry* entry) {
     // Note that |entry| is ref-counted.
     entry->Close();
   }
 };
 
 // Automatically closes an entry when it goes out of scope.
 typedef scoped_ptr<Entry, EntryDeleter> ScopedEntryPtr;
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_