Make mojo dart controller depend on tonic and get building without wtf

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 "tonic/dart_library_loader.h"
 
 #include "base/callback.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/common/data_pipe_drainer.h"
 #include "tonic/dart_api_scope.h"
@@ skipping 38 matching lines @@
   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()));
+    drainer_ = std::unique_ptr<DataPipeDrainer>(
+        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.
 
   std::string name_;
-  OwnPtr<DataPipeDrainer> drainer_;
+  std::unique_ptr<DataPipeDrainer> drainer_;
 
   base::WeakPtrFactory<Job> weak_factory_;
 };
 
 class DartLibraryLoader::ImportJob : public Job {
  public:
   ImportJob(DartLibraryLoader* loader, const std::string& name) : Job(loader, name) {
     TRACE_EVENT_ASYNC_BEGIN1("sky", "DartLibraryLoader::ImportJob", this, "url",
                              name);
   }
@@ skipping 62 matching lines @@
 // 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.
 class DartLibraryLoader::WatcherSignaler {
  public:
   WatcherSignaler(DartLibraryLoader& loader,
                   DartDependency* resolved_dependency)
       : loader_(loader),
-        catcher_(adoptPtr(new DartDependencyCatcher(loader))),
+        catcher_(std::unique_ptr<DartDependencyCatcher>(
+                    new DartDependencyCatcher(loader))),
         resolved_dependency_(resolved_dependency) {}
 
   ~WatcherSignaler() {
     std::vector<DependencyWatcher*> completed_watchers;
     for (const auto& watcher : loader_.dependency_watchers_) {
       if (watcher->DidResolveDependency(resolved_dependency_,
                                         catcher_->dependencies()))
         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();
+    catcher_.reset();
     std::vector<base::Closure> callbacks;
     for (const auto& watcher : completed_watchers) {
       callbacks.push_back(watcher->callback());
       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_;
+  std::unique_ptr<DartDependencyCatcher> catcher_;
   DartDependency* resolved_dependency_;
 };
 
 DartLibraryLoader::DartLibraryLoader(DartState* dart_state)
     : dart_state_(dart_state),
       library_provider_(nullptr),
       dependency_catcher_(nullptr) {
 }
 
 DartLibraryLoader::~DartLibraryLoader() {
@@ skipping 104 matching lines @@
 
   WatcherSignaler watcher_signaler(*this, job);
 
   LOG(ERROR) << "Library Load failed: " << job->name();
   // TODO(eseidel): Call Dart_LibraryHandleError in the SourceJob case?
 
   EraseUniquePtr<Job>(jobs_, job);
 }
 
 }  // namespace blink