1 files changed, 25 insertions, 25 deletions

diff --git a/patchoat/patchoat.cc b/patchoat/patchoat.cc
index a15f7b88d8..02fc92533f 100644
--- a/patchoat/patchoat.cc
+++ b/patchoat/patchoat.cc
@@ -538,7 +538,7 @@ bool PatchOat::Patch(const std::string& image_location,
   ScopedObjectAccess soa(Thread::Current());
 
   std::vector<gc::space::ImageSpace*> spaces = Runtime::Current()->GetHeap()->GetBootImageSpaces();
-  std::map<gc::space::ImageSpace*, std::unique_ptr<MemMap>> space_to_memmap_map;
+  std::map<gc::space::ImageSpace*, MemMap> space_to_memmap_map;
 
   for (size_t i = 0; i < spaces.size(); ++i) {
     t.NewTiming("Image Patching setup");
@@ -567,15 +567,15 @@ bool PatchOat::Patch(const std::string& image_location,
 
     // Create the map where we will write the image patches to.
     std::string error_msg;
-    std::unique_ptr<MemMap> image(MemMap::MapFile(image_len,
-                                                  PROT_READ | PROT_WRITE,
-                                                  MAP_PRIVATE,
-                                                  input_image->Fd(),
-                                                  0,
-                                                  /*low_4gb*/false,
-                                                  input_image->GetPath().c_str(),
-                                                  &error_msg));
-    if (image.get() == nullptr) {
+    MemMap image = MemMap::MapFile(image_len,
+                                   PROT_READ | PROT_WRITE,
+                                   MAP_PRIVATE,
+                                   input_image->Fd(),
+                                   0,
+                                   /*low_4gb*/false,
+                                   input_image->GetPath().c_str(),
+                                   &error_msg);
+    if (!image.IsValid()) {
       LOG(ERROR) << "Unable to map image file " << input_image->GetPath() << " : " << error_msg;
       return false;
     }
@@ -583,7 +583,7 @@ bool PatchOat::Patch(const std::string& image_location,
 
     space_to_memmap_map.emplace(space, std::move(image));
     PatchOat p = PatchOat(isa,
-                          space_to_memmap_map[space].get(),
+                          &space_to_memmap_map[space],
                           space->GetLiveBitmap(),
                           space->GetMemMap(),
                           delta,
@@ -636,22 +636,22 @@ bool PatchOat::Patch(const std::string& image_location,
         LOG(ERROR) << "Error while getting input image size";
         return false;
       }
-      std::unique_ptr<MemMap> original(MemMap::MapFile(input_image_size,
-                                                       PROT_READ,
-                                                       MAP_PRIVATE,
-                                                       input_image->Fd(),
-                                                       0,
-                                                       /*low_4gb*/false,
-                                                       input_image->GetPath().c_str(),
-                                                       &error_msg));
-      if (original.get() == nullptr) {
+      MemMap original = MemMap::MapFile(input_image_size,
+                                        PROT_READ,
+                                        MAP_PRIVATE,
+                                        input_image->Fd(),
+                                        0,
+                                        /*low_4gb*/false,
+                                        input_image->GetPath().c_str(),
+                                        &error_msg);
+      if (!original.IsValid()) {
         LOG(ERROR) << "Unable to map image file " << input_image->GetPath() << " : " << error_msg;
         return false;
       }
 
       const MemMap* relocated = p.image_;
 
-      if (!WriteRelFile(*original, *relocated, image_relocation_filename, &error_msg)) {
+      if (!WriteRelFile(original, *relocated, image_relocation_filename, &error_msg)) {
         LOG(ERROR) << "Failed to create image relocation file " << image_relocation_filename
             << ": " << error_msg;
         return false;
@@ -815,7 +815,7 @@ class PatchOat::PatchOatArtFieldVisitor : public ArtFieldVisitor {
  public:
   explicit PatchOatArtFieldVisitor(PatchOat* patch_oat) : patch_oat_(patch_oat) {}
 
-  void Visit(ArtField* field) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
+  void Visit(ArtField* field) override REQUIRES_SHARED(Locks::mutator_lock_) {
     ArtField* const dest = patch_oat_->RelocatedCopyOf(field);
     dest->SetDeclaringClass(
         patch_oat_->RelocatedAddressOfPointer(field->GetDeclaringClass().Ptr()));
@@ -834,7 +834,7 @@ class PatchOat::PatchOatArtMethodVisitor : public ArtMethodVisitor {
  public:
   explicit PatchOatArtMethodVisitor(PatchOat* patch_oat) : patch_oat_(patch_oat) {}
 
-  void Visit(ArtMethod* method) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
+  void Visit(ArtMethod* method) override REQUIRES_SHARED(Locks::mutator_lock_) {
     ArtMethod* const dest = patch_oat_->RelocatedCopyOf(method);
     patch_oat_->FixupMethod(method, dest);
   }
@@ -877,7 +877,7 @@ class PatchOat::FixupRootVisitor : public RootVisitor {
   }
 
   void VisitRoots(mirror::Object*** roots, size_t count, const RootInfo& info ATTRIBUTE_UNUSED)
-      OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
+      override REQUIRES_SHARED(Locks::mutator_lock_) {
     for (size_t i = 0; i < count; ++i) {
       *roots[i] = patch_oat_->RelocatedAddressOfPointer(*roots[i]);
     }
@@ -885,7 +885,7 @@ class PatchOat::FixupRootVisitor : public RootVisitor {
 
   void VisitRoots(mirror::CompressedReference<mirror::Object>** roots, size_t count,
                   const RootInfo& info ATTRIBUTE_UNUSED)
-      OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
+      override REQUIRES_SHARED(Locks::mutator_lock_) {
     for (size_t i = 0; i < count; ++i) {
       roots[i]->Assign(patch_oat_->RelocatedAddressOfPointer(roots[i]->AsMirrorPtr()));
     }