Remove OwnPtr from Blink.

third_party/WebKit/Source/web/WebDevToolsAgentImpl.cpp

 /*
  * Copyright (C) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 72 matching lines @@
 #include "web/InspectorEmulationAgent.h"
 #include "web/InspectorOverlay.h"
 #include "web/InspectorRenderingAgent.h"
 #include "web/WebFrameWidgetImpl.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/WebViewImpl.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
+#include <memory>
 
 namespace blink {
 
 namespace {
 
 bool isMainFrame(WebLocalFrameImpl* frame)
 {
     // TODO(dgozman): sometimes view->mainFrameImpl() does return null, even though |frame| is meant to be main frame.
     // See http://crbug.com/526162.
     return frame->viewImpl() && !frame->parent();
 }
 
 }
 
 class ClientMessageLoopAdapter : public MainThreadDebugger::ClientMessageLoop {
 public:
     ~ClientMessageLoopAdapter() override
     {
         s_instance = nullptr;
     }
 
     static void ensureMainThreadDebuggerCreated(WebDevToolsAgentClient* client)
     {
         if (s_instance)
             return;
-        OwnPtr<ClientMessageLoopAdapter> instance = adoptPtr(new ClientMessageLoopAdapter(adoptPtr(client->createClientMessageLoop())));
+        std::unique_ptr<ClientMessageLoopAdapter> instance = wrapUnique(new ClientMessageLoopAdapter(wrapUnique(client->createClientMessageLoop())));
         s_instance = instance.get();
         MainThreadDebugger::instance()->setClientMessageLoop(std::move(instance));
     }
 
     static void webViewImplClosed(WebViewImpl* view)
     {
         if (s_instance)
             s_instance->m_frozenViews.remove(view);
     }
 
@@ skipping 15 matching lines @@
         if (s_instance)
             s_instance->runForCreateWindow(frame);
     }
 
     static bool resumeForCreateWindow()
     {
         return s_instance ? s_instance->quitForCreateWindow() : false;
     }
 
 private:
-    ClientMessageLoopAdapter(PassOwnPtr<WebDevToolsAgentClient::WebKitClientMessageLoop> messageLoop)
+    ClientMessageLoopAdapter(std::unique_ptr<WebDevToolsAgentClient::WebKitClientMessageLoop> messageLoop)
         : m_runningForDebugBreak(false)
         , m_runningForCreateWindow(false)
         , m_messageLoop(std::move(messageLoop)) { }
 
     void run(LocalFrame* frame) override
     {
         if (m_runningForDebugBreak)
             return;
 
         m_runningForDebugBreak = true;
@@ skipping 91 matching lines @@
             m_runningForCreateWindow = false;
             if (!m_runningForDebugBreak)
                 m_messageLoop->quitNow();
             return true;
         }
         return false;
     }
 
     bool m_runningForDebugBreak;
     bool m_runningForCreateWindow;
-    OwnPtr<WebDevToolsAgentClient::WebKitClientMessageLoop> m_messageLoop;
+    std::unique_ptr<WebDevToolsAgentClient::WebKitClientMessageLoop> m_messageLoop;
     typedef HashSet<WebViewImpl*> FrozenViewsSet;
     FrozenViewsSet m_frozenViews;
     WebFrameWidgetsSet m_frozenWidgets;
     static ClientMessageLoopAdapter* s_instance;
 };
 
 ClientMessageLoopAdapter* ClientMessageLoopAdapter::s_instance = nullptr;
 
 // static
 WebDevToolsAgentImpl* WebDevToolsAgentImpl::create(WebLocalFrameImpl* frame, WebDevToolsAgentClient* client)
@@ skipping 358 matching lines @@
 }
 
 void WebDevToolsAgentImpl::didProcessTask()
 {
     if (!attached())
         return;
     ThreadDebugger::idleStarted(V8PerIsolateData::mainThreadIsolate());
     flushProtocolNotifications();
 }
 
-void WebDevToolsAgentImpl::runDebuggerTask(int sessionId, PassOwnPtr<WebDevToolsAgent::MessageDescriptor> descriptor)
+void WebDevToolsAgentImpl::runDebuggerTask(int sessionId, std::unique_ptr<WebDevToolsAgent::MessageDescriptor> descriptor)
 {
     WebDevToolsAgent* webagent = descriptor->agent();
     if (!webagent)
         return;
 
     WebDevToolsAgentImpl* agentImpl = static_cast<WebDevToolsAgentImpl*>(webagent);
     if (agentImpl->attached())
         agentImpl->dispatchMessageFromFrontend(sessionId, descriptor->method(), descriptor->message());
 }
 
 void WebDevToolsAgent::interruptAndDispatch(int sessionId, MessageDescriptor* rawDescriptor)
 {
-    // rawDescriptor can't be a PassOwnPtr because interruptAndDispatch is a WebKit API function.
-    MainThreadDebugger::interruptMainThreadAndRun(threadSafeBind(WebDevToolsAgentImpl::runDebuggerTask, sessionId, passed(adoptPtr(rawDescriptor))));
+    // rawDescriptor can't be a std::unique_ptr because interruptAndDispatch is a WebKit API function.
+    MainThreadDebugger::interruptMainThreadAndRun(threadSafeBind(WebDevToolsAgentImpl::runDebuggerTask, sessionId, passed(wrapUnique(rawDescriptor))));
 }
 
 bool WebDevToolsAgent::shouldInterruptForMethod(const WebString& method)
 {
     return method == "Debugger.pause"
         || method == "Debugger.setBreakpoint"
         || method == "Debugger.setBreakpointByUrl"
         || method == "Debugger.removeBreakpoint"
         || method == "Debugger.setBreakpointsActive";
 }
 
 } // namespace blink