blink_gc_plugin: Remove OwnPtr support

Removes support for the no longer used OwnPtr

Bug: 
Change-Id: I38faf4aedb9bbc335c9f61bb5e38771338f1a187
Reviewed-on: https://chromium-review.googlesource.com/720861Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Keishi Hattori <keishi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#509337}

tools/clang/blink_gc_plugin/BlinkGCPluginConsumer.cpp

@@ -590,7 +590,6 @@ void BlinkGCPluginConsumer::DumpClass(RecordInfo* info) {
                        (static_cast<RawPtr*>(Parent())->HasReferenceType() ?
                         "reference" : "raw") :
                    Parent()->IsRefPtr() ? "ref" :
-                   Parent()->IsOwnPtr() ? "own" :
                    Parent()->IsUniquePtr() ? "unique" :
                    (Parent()->IsMember() || Parent()->IsWeakMember()) ? "mem" :
                    "val");

tools/clang/blink_gc_plugin/CheckFieldsVisitor.cpp

@@ -97,9 +97,8 @@ void CheckFieldsVisitor::AtValue(Value* edge) {
   if (!Parent() || !edge->value()->IsGCAllocated())
     return;
 
-  // Disallow  OwnPtr<T>, RefPtr<T> and T* to stack-allocated types.
-  if (Parent()->IsOwnPtr() ||
-      Parent()->IsUniquePtr() ||
+  // Disallow  unique_ptr<T>, RefPtr<T> and T* to stack-allocated types.
+  if (Parent()->IsUniquePtr() ||
       Parent()->IsRefPtr() ||
       (stack_allocated_host_ && Parent()->IsRawPtr())) {
     invalid_fields_.push_back(std::make_pair(
@@ -115,8 +114,6 @@ void CheckFieldsVisitor::AtValue(Value* edge) {
 }
 
 void CheckFieldsVisitor::AtCollection(Collection* edge) {
-  if (edge->on_heap() && Parent() && Parent()->IsOwnPtr())
-    invalid_fields_.push_back(std::make_pair(current_, kOwnPtrToGCManaged));
   if (edge->on_heap() && Parent() && Parent()->IsUniquePtr())
     invalid_fields_.push_back(std::make_pair(current_, kUniquePtrToGCManaged));
 }
@@ -130,8 +127,6 @@ CheckFieldsVisitor::Error CheckFieldsVisitor::InvalidSmartPtr(Edge* ptr) {
   }
   if (ptr->IsRefPtr())
     return kRefPtrToGCManaged;
-  if (ptr->IsOwnPtr())
-    return kOwnPtrToGCManaged;
   if (ptr->IsUniquePtr())
     return kUniquePtrToGCManaged;
   assert(false && "Unknown smart pointer kind");

tools/clang/blink_gc_plugin/CheckFieldsVisitor.h

@@ -13,7 +13,7 @@
 class FieldPoint;
 
 // This visitor checks that the fields of a class are "well formed".
-// - OwnPtr and RefPtr must not point to a GC derived type.
+// - unique_ptr and RefPtr must not point to a GC derived type.
 // - Part objects must not be a GC derived type.
 // - An on-heap class must never contain GC roots.
 // - Only stack-allocated types may point to stack-allocated types.
@@ -24,7 +24,6 @@ class CheckFieldsVisitor : public RecursiveEdgeVisitor {
     kRawPtrToGCManaged,
     kRefPtrToGCManaged,
     kReferencePtrToGCManaged,
-    kOwnPtrToGCManaged,
     kUniquePtrToGCManaged,
     kMemberToGCUnmanaged,
     kMemberInUnmanaged,

tools/clang/blink_gc_plugin/Config.h

@@ -64,10 +64,6 @@ class Config {
     return name == "RefPtr";
   }
 
-  static bool IsOwnPtr(const std::string& name) {
-    return name == "OwnPtr";
-  }
-
   static bool IsUniquePtr(const std::string& name) {
     return name == "unique_ptr";
   }

tools/clang/blink_gc_plugin/DiagnosticsReporter.cpp

@@ -60,9 +60,6 @@ const char kReferencePtrToGCManagedClassNote[] =
     "[blink-gc] Reference pointer field %0 to a GC managed class"
     " declared here:";
 
-const char kOwnPtrToGCManagedClassNote[] =
-    "[blink-gc] OwnPtr field %0 to a GC managed class declared here:";
-
 const char kUniquePtrToGCManagedClassNote[] =
     "[blink-gc] std::unique_ptr field %0 to a GC managed class declared here:";
 
@@ -232,8 +229,6 @@ DiagnosticsReporter::DiagnosticsReporter(
       DiagnosticsEngine::Note, kRefPtrToGCManagedClassNote);
   diag_reference_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kReferencePtrToGCManagedClassNote);
-  diag_own_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
-      DiagnosticsEngine::Note, kOwnPtrToGCManagedClassNote);
   diag_unique_ptr_to_gc_managed_class_note_ = diagnostic_.getCustomDiagID(
       DiagnosticsEngine::Note, kUniquePtrToGCManagedClassNote);
   diag_member_to_gc_unmanaged_class_note_ = diagnostic_.getCustomDiagID(
@@ -342,8 +337,6 @@ void DiagnosticsReporter::ClassContainsInvalidFields(
       note = diag_ref_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kReferencePtrToGCManaged) {
       note = diag_reference_ptr_to_gc_managed_class_note_;
-    } else if (error.second == CheckFieldsVisitor::kOwnPtrToGCManaged) {
-      note = diag_own_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kUniquePtrToGCManaged) {
       note = diag_unique_ptr_to_gc_managed_class_note_;
     } else if (error.second == CheckFieldsVisitor::kMemberToGCUnmanaged) {

tools/clang/blink_gc_plugin/Edge.cpp

@@ -16,7 +16,6 @@ bool Collection::NeedsFinalization() { return info_->NeedsFinalization(); }
 void RecursiveEdgeVisitor::AtValue(Value*) {}
 void RecursiveEdgeVisitor::AtRawPtr(RawPtr*) {}
 void RecursiveEdgeVisitor::AtRefPtr(RefPtr*) {}
-void RecursiveEdgeVisitor::AtOwnPtr(OwnPtr*) {}
 void RecursiveEdgeVisitor::AtUniquePtr(UniquePtr*) {}
 void RecursiveEdgeVisitor::AtMember(Member*) {}
 void RecursiveEdgeVisitor::AtWeakMember(WeakMember*) {}
@@ -42,12 +41,6 @@ void RecursiveEdgeVisitor::VisitRefPtr(RefPtr* e) {
   e->ptr()->Accept(this);
   Leave();
 }
-void RecursiveEdgeVisitor::VisitOwnPtr(OwnPtr* e) {
-  AtOwnPtr(e);
-  Enter(e);
-  e->ptr()->Accept(this);
-  Leave();
-}
 
 void RecursiveEdgeVisitor::VisitUniquePtr(UniquePtr* e) {
   AtUniquePtr(e);

tools/clang/blink_gc_plugin/Edge.h

@@ -18,7 +18,6 @@ class Collection;
 class CrossThreadPersistent;
 class Iterator;
 class Member;
-class OwnPtr;
 class Persistent;
 class RawPtr;
 class RefPtr;
@@ -33,7 +32,6 @@ class EdgeVisitor {
   virtual void VisitValue(Value*) {}
   virtual void VisitRawPtr(RawPtr*) {}
   virtual void VisitRefPtr(RefPtr*) {}
-  virtual void VisitOwnPtr(OwnPtr*) {}
   virtual void VisitUniquePtr(UniquePtr*) {}
   virtual void VisitMember(Member*) {}
   virtual void VisitWeakMember(WeakMember*) {}
@@ -50,7 +48,6 @@ class RecursiveEdgeVisitor : public EdgeVisitor {
   void VisitValue(Value*) override;
   void VisitRawPtr(RawPtr*) override;
   void VisitRefPtr(RefPtr*) override;
-  void VisitOwnPtr(OwnPtr*) override;
   void VisitUniquePtr(UniquePtr*) override;
   void VisitMember(Member*) override;
   void VisitWeakMember(WeakMember*) override;
@@ -70,7 +67,6 @@ class RecursiveEdgeVisitor : public EdgeVisitor {
   virtual void AtValue(Value*);
   virtual void AtRawPtr(RawPtr*);
   virtual void AtRefPtr(RefPtr*);
-  virtual void AtOwnPtr(OwnPtr*);
   virtual void AtUniquePtr(UniquePtr*);
   virtual void AtMember(Member*);
   virtual void AtWeakMember(WeakMember*);
@@ -100,7 +96,6 @@ class Edge {
   virtual bool IsValue() { return false; }
   virtual bool IsRawPtr() { return false; }
   virtual bool IsRefPtr() { return false; }
-  virtual bool IsOwnPtr() { return false; }
   virtual bool IsUniquePtr() { return false; }
   virtual bool IsMember() { return false; }
   virtual bool IsWeakMember() { return false; }
@@ -168,18 +163,6 @@ class RefPtr : public PtrEdge {
   void Accept(EdgeVisitor* visitor) override { visitor->VisitRefPtr(this); }
 };
 
-class OwnPtr : public PtrEdge {
- public:
-  explicit OwnPtr(Edge* ptr) : PtrEdge(ptr) { }
-  bool IsOwnPtr() override { return true; }
-  LivenessKind Kind() override { return kStrong; }
-  bool NeedsFinalization() override { return true; }
-  TracingStatus NeedsTracing(NeedsTracingOption) override {
-    return TracingStatus::Illegal();
-  }
-  void Accept(EdgeVisitor* visitor) override { visitor->VisitOwnPtr(this); }
-};
-
 class UniquePtr : public PtrEdge {
  public:
   explicit UniquePtr(Edge* ptr) : PtrEdge(ptr) { }

tools/clang/blink_gc_plugin/RecordInfo.cpp

@@ -625,12 +625,6 @@ Edge* RecordInfo::CreateEdge(const Type* type) {
     return 0;
   }
 
-  if (Config::IsOwnPtr(info->name()) && info->GetTemplateArgs(1, &args)) {
-    if (Edge* ptr = CreateEdge(args[0]))
-      return new OwnPtr(ptr);
-    return 0;
-  }
-
   if (Config::IsUniquePtr(info->name()) && info->GetTemplateArgs(1, &args)) {
     // Check that this is std::unique_ptr
     NamespaceDecl* ns =

tools/clang/blink_gc_plugin/tests/cycle_ptrs.h

@@ -36,12 +36,12 @@ private:
 
 class C : public RefCounted<C> {
 private:
-    OwnPtr<D> m_d;
+    std::unique_ptr<D> m_d;
 };
 
 class D {
 private:
-    Vector<OwnPtr<E> > m_es;
+    Vector<std::unique_ptr<E> > m_es;
 };
 
 class E {

tools/clang/blink_gc_plugin/tests/fields_illegal_tracing.cpp

@@ -7,14 +7,12 @@
 namespace blink {
 
 void PartObject::Trace(Visitor* visitor) {
-    visitor->Trace(m_obj1);
     visitor->Trace(m_obj2);
     visitor->Trace(m_obj3);
     visitor->Trace(m_obj4);
 }
 
 void HeapObject::Trace(Visitor* visitor) {
-    visitor->Trace(m_obj1);
     visitor->Trace(m_obj2);
     visitor->Trace(m_obj3);
     visitor->Trace(m_obj4);

tools/clang/blink_gc_plugin/tests/fields_illegal_tracing.h

@@ -34,7 +34,6 @@ class PartObject {
 public:
     void Trace(Visitor*);
 private:
-    OwnPtr<HeapObject> m_obj1;
     RefPtr<HeapObject> m_obj2;
     bar::unique_ptr<HeapObject> m_obj3;
     std::unique_ptr<HeapObject> m_obj4;
@@ -48,7 +47,6 @@ public:
     void Trace(Visitor*);
 private:
     PartObject m_part;
-    OwnPtr<HeapObject> m_obj1;
     RefPtr<HeapObject> m_obj2;
     bar::unique_ptr<HeapObject> m_obj3;
     std::unique_ptr<HeapObject> m_obj4;

tools/clang/blink_gc_plugin/tests/fields_illegal_tracing.txt

@@ -2,67 +2,55 @@ In file included from fields_illegal_tracing.cpp:5:
 ./fields_illegal_tracing.h:32:1: warning: [blink-gc] Class 'PartObject' contains invalid fields.
 class PartObject {
 ^
-./fields_illegal_tracing.h:37:5: note: [blink-gc] OwnPtr field 'm_obj1' to a GC managed class declared here:
-    OwnPtr<HeapObject> m_obj1;
-    ^
-./fields_illegal_tracing.h:38:5: note: [blink-gc] RefPtr field 'm_obj2' to a GC managed class declared here:
+./fields_illegal_tracing.h:37:5: note: [blink-gc] RefPtr field 'm_obj2' to a GC managed class declared here:
     RefPtr<HeapObject> m_obj2;
     ^
-./fields_illegal_tracing.h:40:5: note: [blink-gc] std::unique_ptr field 'm_obj4' to a GC managed class declared here:
+./fields_illegal_tracing.h:39:5: note: [blink-gc] std::unique_ptr field 'm_obj4' to a GC managed class declared here:
     std::unique_ptr<HeapObject> m_obj4;
     ^
-./fields_illegal_tracing.h:42:5: warning: [blink-gc] Iterator field 'm_iterator2' to a GC managed collection declared here:
+./fields_illegal_tracing.h:41:5: warning: [blink-gc] Iterator field 'm_iterator2' to a GC managed collection declared here:
     HeapVector<Member<HeapObject>>::iterator m_iterator2;
     ^
-./fields_illegal_tracing.h:43:5: warning: [blink-gc] Iterator field 'm_iterator3' to a GC managed collection declared here:
+./fields_illegal_tracing.h:42:5: warning: [blink-gc] Iterator field 'm_iterator3' to a GC managed collection declared here:
     HeapHashSet<PartObject>::const_iterator m_iterator3;
     ^
-./fields_illegal_tracing.h:46:1: warning: [blink-gc] Class 'HeapObject' contains invalid fields.
+./fields_illegal_tracing.h:45:1: warning: [blink-gc] Class 'HeapObject' contains invalid fields.
 class HeapObject : public GarbageCollectedFinalized<HeapObject> {
 ^
-./fields_illegal_tracing.h:51:5: note: [blink-gc] OwnPtr field 'm_obj1' to a GC managed class declared here:
-    OwnPtr<HeapObject> m_obj1;
-    ^
-./fields_illegal_tracing.h:52:5: note: [blink-gc] RefPtr field 'm_obj2' to a GC managed class declared here:
+./fields_illegal_tracing.h:50:5: note: [blink-gc] RefPtr field 'm_obj2' to a GC managed class declared here:
     RefPtr<HeapObject> m_obj2;
     ^
-./fields_illegal_tracing.h:54:5: note: [blink-gc] std::unique_ptr field 'm_obj4' to a GC managed class declared here:
+./fields_illegal_tracing.h:52:5: note: [blink-gc] std::unique_ptr field 'm_obj4' to a GC managed class declared here:
     std::unique_ptr<HeapObject> m_obj4;
     ^
-./fields_illegal_tracing.h:55:5: warning: [blink-gc] Iterator field 'm_iterator3' to a GC managed collection declared here:
+./fields_illegal_tracing.h:53:5: warning: [blink-gc] Iterator field 'm_iterator3' to a GC managed collection declared here:
     HeapHashMap<int, Member<HeapObject>>::reverse_iterator m_iterator3;
     ^
-./fields_illegal_tracing.h:56:5: warning: [blink-gc] Iterator field 'm_iterator4' to a GC managed collection declared here:
+./fields_illegal_tracing.h:54:5: warning: [blink-gc] Iterator field 'm_iterator4' to a GC managed collection declared here:
     HeapDeque<Member<HeapObject>>::const_reverse_iterator m_iterator4;
     ^
-./fields_illegal_tracing.h:58:5: warning: [blink-gc] Iterator field 'm_iterator6' to a GC managed collection declared here:
+./fields_illegal_tracing.h:56:5: warning: [blink-gc] Iterator field 'm_iterator6' to a GC managed collection declared here:
     HeapLinkedHashSet<Member<HeapObject>>::const_iterator m_iterator6;
     ^
 fields_illegal_tracing.cpp:9:1: warning: [blink-gc] Class 'PartObject' has untraced or not traceable fields.
 void PartObject::Trace(Visitor* visitor) {
 ^
-./fields_illegal_tracing.h:37:5: note: [blink-gc] Untraceable field 'm_obj1' declared here:
-    OwnPtr<HeapObject> m_obj1;
-    ^
-./fields_illegal_tracing.h:38:5: note: [blink-gc] Untraceable field 'm_obj2' declared here:
+./fields_illegal_tracing.h:37:5: note: [blink-gc] Untraceable field 'm_obj2' declared here:
     RefPtr<HeapObject> m_obj2;
     ^
-./fields_illegal_tracing.h:40:5: note: [blink-gc] Untraceable field 'm_obj4' declared here:
+./fields_illegal_tracing.h:39:5: note: [blink-gc] Untraceable field 'm_obj4' declared here:
     std::unique_ptr<HeapObject> m_obj4;
     ^
-fields_illegal_tracing.cpp:16:1: warning: [blink-gc] Class 'HeapObject' has untraced or not traceable fields.
+fields_illegal_tracing.cpp:15:1: warning: [blink-gc] Class 'HeapObject' has untraced or not traceable fields.
 void HeapObject::Trace(Visitor* visitor) {
 ^
-./fields_illegal_tracing.h:51:5: note: [blink-gc] Untraceable field 'm_obj1' declared here:
-    OwnPtr<HeapObject> m_obj1;
-    ^
-./fields_illegal_tracing.h:52:5: note: [blink-gc] Untraceable field 'm_obj2' declared here:
+./fields_illegal_tracing.h:50:5: note: [blink-gc] Untraceable field 'm_obj2' declared here:
     RefPtr<HeapObject> m_obj2;
     ^
-./fields_illegal_tracing.h:54:5: note: [blink-gc] Untraceable field 'm_obj4' declared here:
+./fields_illegal_tracing.h:52:5: note: [blink-gc] Untraceable field 'm_obj4' declared here:
     std::unique_ptr<HeapObject> m_obj4;
     ^
-./fields_illegal_tracing.h:57:5: note: [blink-gc] Untraced field 'm_iterator5' declared here:
+./fields_illegal_tracing.h:55:5: note: [blink-gc] Untraced field 'm_iterator5' declared here:
     HeapListHashSet<Member<HeapObject>>::const_iterator m_iterator5;
     ^
 9 warnings generated.

tools/clang/blink_gc_plugin/tests/heap/stubs.h

@@ -32,13 +32,6 @@ public:
     T* operator->() { return 0; }
 };
 
-template<typename T> class OwnPtr {
-public:
-    ~OwnPtr() { }
-    operator T*() const { return 0; }
-    T* operator->() { return 0; }
-};
-
 class DefaultAllocator {
 public:
     static const bool isGarbageCollected = false;

tools/clang/blink_gc_plugin/tests/own_ptr_to_gc_managed_class.txt

-In file included from own_ptr_to_gc_managed_class.cpp:5:
-./own_ptr_to_gc_managed_class.h:14:1: warning: [blink-gc] Class 'PartObject' contains invalid fields.
-class PartObject {
-^
-./own_ptr_to_gc_managed_class.h:17:5: note: [blink-gc] OwnPtr field 'm_obj' to a GC managed class declared here:
-    OwnPtr<HeapObject> m_obj;
-    ^
-./own_ptr_to_gc_managed_class.h:20:1: warning: [blink-gc] Class 'HeapObject' contains invalid fields.
-class HeapObject : public GarbageCollectedFinalized<HeapObject> {
-^
-./own_ptr_to_gc_managed_class.h:24:5: note: [blink-gc] OwnPtr field 'm_objs' to a GC managed class declared here:
-    Vector<OwnPtr<HeapObject> > m_objs;
-    ^
-./own_ptr_to_gc_managed_class.h:25:5: note: [blink-gc] OwnPtr field 'm_objs2' to a GC managed class declared here:
-    OwnPtr<HeapVector<Member<HeapObject> > > m_objs2;
-    ^
-2 warnings generated.

tools/clang/blink_gc_plugin/tests/stack_allocated.txt

@@ -23,7 +23,7 @@ class DerivedHeapObject2 : public HeapObject {
 ./stack_allocated.h:43:3: warning: [blink-gc] Garbage collected class 'DerivedHeapObject2' is not permitted to override its new operator.
   STACK_ALLOCATED();
   ^
-./heap/stubs.h:178:5: note: expanded from macro 'STACK_ALLOCATED'
+./heap/stubs.h:171:5: note: expanded from macro 'STACK_ALLOCATED'
     __attribute__((annotate("blink_stack_allocated")))      \
     ^
 stack_allocated.cpp:12:1: warning: [blink-gc] Class 'AnonStackObject' contains invalid fields.

tools/clang/blink_gc_plugin/tests/templated_class_with_local_class_requires_trace.h

@@ -38,12 +38,12 @@ private:
         }
     private:
         Member<HeapObject> m_heapObject;
-        OwnPtr<HeapObject> m_object;
+        std::unique_ptr<HeapObject> m_object;
     };
 
     Member<Local> m_local;
     Member<T> m_memberRef;
-    OwnPtr<T> m_ownRef;
+    std::unique_ptr<T> m_uniqueRef;
 };
 
 } // namespace blink

tools/clang/blink_gc_plugin/tests/templated_class_with_local_class_requires_trace.txt

@@ -2,25 +2,25 @@ In file included from templated_class_with_local_class_requires_trace.cpp:5:
 ./templated_class_with_local_class_requires_trace.h:22:1: warning: [blink-gc] Class 'TemplatedObject<blink::HeapObject>' contains invalid fields.
 class TemplatedObject final
 ^
-./templated_class_with_local_class_requires_trace.h:46:5: note: [blink-gc] OwnPtr field 'm_ownRef' to a GC managed class declared here:
-    OwnPtr<T> m_ownRef;
+./templated_class_with_local_class_requires_trace.h:46:5: note: [blink-gc] std::unique_ptr field 'm_uniqueRef' to a GC managed class declared here:
+    std::unique_ptr<T> m_uniqueRef;
     ^
 ./templated_class_with_local_class_requires_trace.h:32:5: warning: [blink-gc] Class 'Local' contains invalid fields.
     class Local final : public GarbageCollected<Local> {
     ^
-./templated_class_with_local_class_requires_trace.h:41:9: note: [blink-gc] OwnPtr field 'm_object' to a GC managed class declared here:
-        OwnPtr<HeapObject> m_object;
+./templated_class_with_local_class_requires_trace.h:41:9: note: [blink-gc] std::unique_ptr field 'm_object' to a GC managed class declared here:
+        std::unique_ptr<HeapObject> m_object;
         ^
 ./templated_class_with_local_class_requires_trace.h:32:5: warning: [blink-gc] Class 'Local' requires finalization.
     class Local final : public GarbageCollected<Local> {
     ^
 ./templated_class_with_local_class_requires_trace.h:41:9: note: [blink-gc] Field 'm_object' requiring finalization declared here:
-        OwnPtr<HeapObject> m_object;
+        std::unique_ptr<HeapObject> m_object;
         ^
 ./templated_class_with_local_class_requires_trace.h:34:9: warning: [blink-gc] Class 'Local' has untraced or not traceable fields.
         void Trace(Visitor* visitor)
         ^
 ./templated_class_with_local_class_requires_trace.h:41:9: note: [blink-gc] Untraceable field 'm_object' declared here:
-        OwnPtr<HeapObject> m_object;
+        std::unique_ptr<HeapObject> m_object;
         ^
 4 warnings generated.

tools/clang/blink_gc_plugin/tests/own_ptr_to_gc_managed_class.cpp → tools/clang/blink_gc_plugin/tests/unique_ptr_to_gc_managed_class.cpp

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "own_ptr_to_gc_managed_class.h"
+#include "unique_ptr_to_gc_managed_class.h"
 
 namespace blink {
 

tools/clang/blink_gc_plugin/tests/own_ptr_to_gc_managed_class.h → tools/clang/blink_gc_plugin/tests/unique_ptr_to_gc_managed_class.h

@@ -14,15 +14,15 @@ class HeapObject;
 class PartObject {
     DISALLOW_NEW();
 private:
-    OwnPtr<HeapObject> m_obj;
+    std::unique_ptr<HeapObject> m_obj;
 };
 
 class HeapObject : public GarbageCollectedFinalized<HeapObject> {
 public:
     void Trace(Visitor*);
 private:
-    Vector<OwnPtr<HeapObject> > m_objs;
-    OwnPtr<HeapVector<Member<HeapObject> > > m_objs2;
+    Vector<std::unique_ptr<HeapObject> > m_objs;
+    std::unique_ptr<HeapVector<Member<HeapObject> > > m_objs2;
 };
 
 }

tools/clang/blink_gc_plugin/tests/unique_ptr_to_gc_managed_class.txt

+In file included from unique_ptr_to_gc_managed_class.cpp:5:
+./unique_ptr_to_gc_managed_class.h:14:1: warning: [blink-gc] Class 'PartObject' contains invalid fields.
+class PartObject {
+^
+./unique_ptr_to_gc_managed_class.h:17:5: note: [blink-gc] std::unique_ptr field 'm_obj' to a GC managed class declared here:
+    std::unique_ptr<HeapObject> m_obj;
+    ^
+./unique_ptr_to_gc_managed_class.h:20:1: warning: [blink-gc] Class 'HeapObject' contains invalid fields.
+class HeapObject : public GarbageCollectedFinalized<HeapObject> {
+^
+./unique_ptr_to_gc_managed_class.h:24:5: note: [blink-gc] std::unique_ptr field 'm_objs' to a GC managed class declared here:
+    Vector<std::unique_ptr<HeapObject> > m_objs;
+    ^
+./unique_ptr_to_gc_managed_class.h:25:5: note: [blink-gc] std::unique_ptr field 'm_objs2' to a GC managed class declared here:
+    std::unique_ptr<HeapVector<Member<HeapObject> > > m_objs2;
+    ^
+2 warnings generated.