Remove all remaining HashMap and HashSet usages except dart_string_cache

sky/engine/tonic/dart_library_loader.cc

 // Copyright 2015 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 "sky/engine/tonic/dart_library_loader.h"
 
 #include "base/callback.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/common/data_pipe_drainer.h"
 #include "sky/engine/tonic/dart_api_scope.h"
 #include "sky/engine/tonic/dart_converter.h"
 #include "sky/engine/tonic/dart_dependency_catcher.h"
 #include "sky/engine/tonic/dart_error.h"
 #include "sky/engine/tonic/dart_isolate_scope.h"
 #include "sky/engine/tonic/dart_library_provider.h"
 #include "sky/engine/tonic/dart_state.h"
 #include "sky/engine/wtf/MainThread.h"
 
 using mojo::common::DataPipeDrainer;
 
 namespace blink {
 
+// Helper to erase a T* from a container of std::unique_ptr<T>s.
+template<typename T, typename C>
+void EraseUniquePtr(C& c, T* t) {
+  std::unique_ptr<T> temp_ptr = std::unique_ptr<T>(t);
+  c.erase(temp_ptr);
+  temp_ptr.release();
+}

[abarth-chromium, 2015/07/16 16:50:42]

Please wrap this function in an anonymous namespace and use complete words for
variable names:

c -> collection
t -> item
temp_ptr -> ??

[Cutch, 2015/07/16 17:00:51]

Done. temp_ptr -> key.

+
 // A DartLibraryLoader::Job represents a network load. It fetches data from the
 // network and buffers the data in std::vector. To cancel the job, delete this
 // object.
 class DartLibraryLoader::Job : public DartDependency,
                                public DataPipeDrainer::Client {
  public:
   Job(DartLibraryLoader* loader, const std::string& name)
       : loader_(loader), name_(name), weak_factory_(this) {
     loader->library_provider()->GetLibraryAsStream(
         name, base::Bind(&Job::OnStreamAvailable, weak_factory_.GetWeakPtr()));
@@ skipping 62 matching lines @@
 
   DartPersistentValue library_;
 };
 
 // A DependencyWatcher represents a request to watch for when a given set of
 // dependencies (either libraries or parts of libraries) have finished loading.
 // When the dependencies are satisfied (including transitive dependencies), then
 // the |callback| will be invoked.
 class DartLibraryLoader::DependencyWatcher {
  public:
-  DependencyWatcher(const HashSet<DartDependency*>& dependencies,
+  DependencyWatcher(const std::unordered_set<DartDependency*>& dependencies,
                     const base::Closure& callback)
       : dependencies_(dependencies), callback_(callback) {
-    DCHECK(!dependencies_.isEmpty());
+    DCHECK(!dependencies_.empty());
   }
 
-  bool DidResolveDependency(DartDependency* resolved_dependency,
-                            const HashSet<DartDependency*>& new_dependencies) {
+  bool DidResolveDependency(
+      DartDependency* resolved_dependency,
+      const std::unordered_set<DartDependency*>& new_dependencies) {
     const auto& it = dependencies_.find(resolved_dependency);
     if (it == dependencies_.end())
       return false;
-    dependencies_.remove(it);
+    dependencies_.erase(it);
     for (const auto& dependency : new_dependencies)
-      dependencies_.add(dependency);
-    return dependencies_.isEmpty();
+      dependencies_.insert(dependency);
+    return dependencies_.empty();
   }
 
   const base::Closure& callback() const { return callback_; }
 
  private:
-  HashSet<DartDependency*> dependencies_;
+  std::unordered_set<DartDependency*> dependencies_;
   base::Closure callback_;
 };
 
 // A WatcherSignaler is responsible for signaling DependencyWatchers when their
 // dependencies resolve and for calling the DependencyWatcher's callback. We use
 // a separate object of this task because we want to carefully manage when we
 // call the callbacks, which can call into us again reentrantly.
 //
 // WatcherSignaler is designed to be placed on the stack as a RAII. After its
 // destructor runs, we might have executed aribitrary script.
@@ skipping 13 matching lines @@
         completed_watchers.push_back(watcher.get());
     }
 
     // Notice that we remove the dependency catcher and extract all the
     // callbacks before running any of them. We don't want to be re-entered
     // below the callbacks and end up in an inconsistent state.
     catcher_.clear();
     std::vector<base::Closure> callbacks;
     for (const auto& watcher : completed_watchers) {
       callbacks.push_back(watcher->callback());
-      loader_.dependency_watchers_.remove(watcher);
+      EraseUniquePtr(loader_.dependency_watchers_, watcher);
     }
 
     // Finally, run all the callbacks while touching only data on the stack.
     for (const auto& callback : callbacks)
       callback.Run();
   }
 
  private:
   DartLibraryLoader& loader_;
   OwnPtr<DartDependencyCatcher> catcher_;
@@ skipping 22 matching lines @@
   }
   if (tag == Dart_kSourceTag) {
     CHECK(WTF::isMainThread());
     return DartState::Current()->library_loader().Source(library, url);
   }
   DCHECK(false);
   return Dart_NewApiError("Unknown library tag.");
 }
 
 void DartLibraryLoader::WaitForDependencies(
-    const HashSet<DartDependency*>& dependencies,
+    const std::unordered_set<DartDependency*>& dependencies,
     const base::Closure& callback) {
-  if (dependencies.isEmpty())
+  if (dependencies.empty())
     return callback.Run();
-  dependency_watchers_.add(
-      adoptPtr(new DependencyWatcher(dependencies, callback)));
+  dependency_watchers_.insert(
+      std::unique_ptr<DependencyWatcher>(
+          new DependencyWatcher(dependencies, callback)));
 }
 
 void DartLibraryLoader::LoadLibrary(const std::string& name) {
   const auto& result = pending_libraries_.insert(std::make_pair(name, nullptr));
   if (result.second) {
     // New entry.
-    OwnPtr<Job> job = adoptPtr(new ImportJob(this, name));
+    std::unique_ptr<Job> job = std::unique_ptr<Job>(new ImportJob(this, name));
     result.first->second = job.get();
-    jobs_.add(job.release());
+    jobs_.insert(std::move(job));
   }
   if (dependency_catcher_)
     dependency_catcher_->AddDependency(result.first->second);
 }
 
 Dart_Handle DartLibraryLoader::Import(Dart_Handle library, Dart_Handle url) {
   LoadLibrary(StdStringFromDart(url));
   return Dart_True();
 }
 
 Dart_Handle DartLibraryLoader::Source(Dart_Handle library, Dart_Handle url) {
-  OwnPtr<Job> job =
-      adoptPtr(new SourceJob(this, StdStringFromDart(url), library));
+  std::unique_ptr<Job> job = std::unique_ptr<Job>(
+      new SourceJob(this, StdStringFromDart(url), library));
   if (dependency_catcher_)
     dependency_catcher_->AddDependency(job.get());
-  jobs_.add(job.release());
+  jobs_.insert(std::move(job));
   return Dart_True();
 }
 
 Dart_Handle DartLibraryLoader::CanonicalizeURL(Dart_Handle library,
                                                Dart_Handle url) {
   return library_provider_->CanonicalizeURL(library, url);
 }
 
 void DartLibraryLoader::DidCompleteImportJob(
     ImportJob* job,
     const std::vector<uint8_t>& buffer) {
   DartIsolateScope scope(dart_state_->isolate());
   DartApiScope api_scope;
 
   WatcherSignaler watcher_signaler(*this, job);
 
   Dart_Handle result = Dart_LoadLibrary(
       StdStringToDart(job->name()),
       Dart_NewStringFromUTF8(buffer.data(), buffer.size()), 0, 0);
   if (Dart_IsError(result)) {
     LOG(ERROR) << "Error Loading " << job->name() << " "
         << Dart_GetError(result);
   }
 
   pending_libraries_.erase(job->name());
-  jobs_.remove(job);
+  EraseUniquePtr<Job>(jobs_, job);
 }
 
 void DartLibraryLoader::DidCompleteSourceJob(
     SourceJob* job,
     const std::vector<uint8_t>& buffer) {
   DartIsolateScope scope(dart_state_->isolate());
   DartApiScope api_scope;
 
   WatcherSignaler watcher_signaler(*this, job);
 
   Dart_Handle result = Dart_LoadSource(
       Dart_HandleFromPersistent(job->library()),
       StdStringToDart(job->name()),
       Dart_NewStringFromUTF8(buffer.data(), buffer.size()), 0, 0);
 
   if (Dart_IsError(result)) {
     LOG(ERROR) << "Error Loading " << job->name() << " "
         << Dart_GetError(result);
   }
 
-  jobs_.remove(job);
+  EraseUniquePtr<Job>(jobs_, job);
 }
 
 void DartLibraryLoader::DidFailJob(Job* job) {
   DartIsolateScope scope(dart_state_->isolate());
   DartApiScope api_scope;
 
   WatcherSignaler watcher_signaler(*this, job);
 
   LOG(ERROR) << "Library Load failed: " << job->name();
   // TODO(eseidel): Call Dart_LibraryHandleError in the SourceJob case?
 
-  jobs_.remove(job);
+  EraseUniquePtr<Job>(jobs_, job);
 }
 
 }  // namespace blink