Port more String and HashMap usages

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 {
 
 // 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 String& name)
+  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()));
   }
 
-  const String& name() const { return name_; }
+  const std::string& name() const { return name_; }
 
  protected:
   DartLibraryLoader* loader_;
   // TODO(abarth): Should we be using SharedBuffer to buffer the data?
   std::vector<uint8_t> buffer_;
 
  private:
   void OnStreamAvailable(mojo::ScopedDataPipeConsumerHandle pipe) {
     if (!pipe.is_valid()) {
       loader_->DidFailJob(this);
       return;
     }
     drainer_ = adoptPtr(new DataPipeDrainer(this, pipe.Pass()));
   }
 
   // DataPipeDrainer::Client
   void OnDataAvailable(const void* data, size_t num_bytes) override {
     const uint8_t* bytes = static_cast<const uint8_t*>(data);
     buffer_.insert(buffer_.end(), bytes, bytes + num_bytes);
   }
   // Subclasses must implement OnDataComplete.
 
-  String name_;
+  std::string name_;
   OwnPtr<DataPipeDrainer> drainer_;
 
   base::WeakPtrFactory<Job> weak_factory_;
 };
 
 class DartLibraryLoader::ImportJob : public Job {
  public:
-  ImportJob(DartLibraryLoader* loader, const String& name) : Job(loader, name) {
+  ImportJob(DartLibraryLoader* loader, const std::string& name) : Job(loader, name) {
     TRACE_EVENT_ASYNC_BEGIN1("sky", "DartLibraryLoader::ImportJob", this, "url",
-                             name.ascii().toStdString());
+                             name);
   }
 
  private:
   // DataPipeDrainer::Client
   void OnDataComplete() override {
     TRACE_EVENT_ASYNC_END0("sky", "DartLibraryLoader::ImportJob", this);
     loader_->DidCompleteImportJob(this, buffer_);
   }
 };
 
 class DartLibraryLoader::SourceJob : public Job {
  public:
-  SourceJob(DartLibraryLoader* loader, const String& name, Dart_Handle library)
+  SourceJob(DartLibraryLoader* loader, const std::string& name, Dart_Handle library)
       : Job(loader, name), library_(loader->dart_state(), library) {
     TRACE_EVENT_ASYNC_BEGIN1("sky", "DartLibraryLoader::SourceJob", this, "url",
-                             name.ascii().toStdString());
+                             name);
   }
 
   Dart_PersistentHandle library() const { return library_.value(); }
 
  private:
   // DataPipeDrainer::Client
   void OnDataComplete() override {
     TRACE_EVENT_ASYNC_END0("sky", "DartLibraryLoader::SourceJob", this);
     loader_->DidCompleteSourceJob(this, buffer_);
   }
@@ skipping 105 matching lines @@
 
 void DartLibraryLoader::WaitForDependencies(
     const HashSet<DartDependency*>& dependencies,
     const base::Closure& callback) {
   if (dependencies.isEmpty())
     return callback.Run();
   dependency_watchers_.add(
       adoptPtr(new DependencyWatcher(dependencies, callback)));
 }
 
-void DartLibraryLoader::LoadLibrary(const String& name) {
-  const auto& result = pending_libraries_.add(name, nullptr);
-  if (result.isNewEntry) {
+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));
-    result.storedValue->value = job.get();
+    result.first->second = job.get();
     jobs_.add(job.release());
   }
   if (dependency_catcher_)
-    dependency_catcher_->AddDependency(result.storedValue->value);
+    dependency_catcher_->AddDependency(result.first->second);
 }
 
 Dart_Handle DartLibraryLoader::Import(Dart_Handle library, Dart_Handle url) {
-  LoadLibrary(StringFromDart(url));
+  LoadLibrary(StdStringFromDart(url));
   return Dart_True();
 }
 
 Dart_Handle DartLibraryLoader::Source(Dart_Handle library, Dart_Handle url) {
-  OwnPtr<Job> job = adoptPtr(new SourceJob(this, StringFromDart(url), library));
+  OwnPtr<Job> job =
+      adoptPtr(new SourceJob(this, StdStringFromDart(url), library));
   if (dependency_catcher_)
     dependency_catcher_->AddDependency(job.get());
   jobs_.add(job.release());
   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(
-      StringToDart(dart_state_, job->name()),
+      StdStringToDart(job->name()),
       Dart_NewStringFromUTF8(buffer.data(), buffer.size()), 0, 0);
   if (Dart_IsError(result)) {
-    LOG(ERROR) << "Error Loading " << job->name().utf8().data() << " "
+    LOG(ERROR) << "Error Loading " << job->name() << " "
         << Dart_GetError(result);
   }
 
-  pending_libraries_.remove(job->name());
+  pending_libraries_.erase(job->name());
   jobs_.remove(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()),
-      StringToDart(dart_state_, job->name()),
+      StdStringToDart(job->name()),
       Dart_NewStringFromUTF8(buffer.data(), buffer.size()), 0, 0);
 
   if (Dart_IsError(result)) {
-    LOG(ERROR) << "Error Loading " << job->name().utf8().data() << " "
+    LOG(ERROR) << "Error Loading " << job->name() << " "
         << Dart_GetError(result);
   }
 
   jobs_.remove(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().utf8().data();
+  LOG(ERROR) << "Library Load failed: " << job->name();
   // TODO(eseidel): Call Dart_LibraryHandleError in the SourceJob case?
 
   jobs_.remove(job);
 }
 
 }  // namespace blink