Remove most usage of Vector

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 Vector. To cancel the job, delete this
+// 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)
       : 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_; }
 
  protected:
   DartLibraryLoader* loader_;
   // TODO(abarth): Should we be using SharedBuffer to buffer the data?
-  Vector<uint8_t> buffer_;
+  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 {
-    buffer_.append(static_cast<const uint8_t*>(data), num_bytes);
+    const uint8_t* bytes = reinterpret_cast<const uint8_t*>(data);

[kulakowski, 2015/07/15 15:00:01]

Why change |static_cast| to |reinterpret_cast|?

+    buffer_.insert(buffer_.end(), bytes, bytes + num_bytes);

[abarth-chromium, 2015/07/15 14:49:32]

Does this do exponential growth?

[kulakowski, 2015/07/15 15:00:01]

Yes, std::vector guarantees it.

   }
   // Subclasses must implement OnDataComplete.
 
   String name_;
   OwnPtr<DataPipeDrainer> drainer_;
 
   base::WeakPtrFactory<Job> weak_factory_;
 };
 
 class DartLibraryLoader::ImportJob : public Job {
@@ skipping 70 matching lines @@
 // destructor runs, we might have executed aribitrary script.
 class DartLibraryLoader::WatcherSignaler {
  public:
   WatcherSignaler(DartLibraryLoader& loader,
                   DartDependency* resolved_dependency)
       : loader_(loader),
         catcher_(adoptPtr(new DartDependencyCatcher(loader))),
         resolved_dependency_(resolved_dependency) {}
 
   ~WatcherSignaler() {
-    Vector<DependencyWatcher*> completed_watchers;
+    std::vector<DependencyWatcher*> completed_watchers;
     for (const auto& watcher : loader_.dependency_watchers_) {
       if (watcher->DidResolveDependency(resolved_dependency_,
                                         catcher_->dependencies()))
-        completed_watchers.append(watcher.get());
+        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();
-    Vector<base::Closure> callbacks;
+    std::vector<base::Closure> callbacks;
     for (const auto& watcher : completed_watchers) {
-      callbacks.append(watcher->callback());
+      callbacks.push_back(watcher->callback());
       loader_.dependency_watchers_.remove(watcher);
     }
 
     // Finally, run all the callbacks while touching only data on the stack.
     for (const auto& callback : callbacks)
       callback.Run();
   }
 
  private:
   DartLibraryLoader& loader_;
@@ skipping 60 matching lines @@
     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 Vector<uint8_t>& buffer) {
+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()),
       Dart_NewStringFromUTF8(buffer.data(), buffer.size()), 0, 0);
   if (Dart_IsError(result)) {
     LOG(ERROR) << "Error Loading " << job->name().utf8().data() << " "
         << Dart_GetError(result);
   }
 
   pending_libraries_.remove(job->name());
   jobs_.remove(job);
 }
 
-void DartLibraryLoader::DidCompleteSourceJob(SourceJob* job,
-                                             const Vector<uint8_t>& buffer) {
+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()),
       Dart_NewStringFromUTF8(buffer.data(), buffer.size()), 0, 0);
 
@@ skipping 11 matching lines @@
 
   WatcherSignaler watcher_signaler(*this, job);
 
   LOG(ERROR) << "Library Load failed: " << job->name().utf8().data();
   // TODO(eseidel): Call Dart_LibraryHandleError in the SourceJob case?
 
   jobs_.remove(job);
 }
 
 }  // namespace blink