Converts Presentation API to use KURL/WebURL in place of string types for...

Converts Presentation API to use KURL/WebURL in place of string types for availability and presentation URLs.  Removes several conversions.

BUG=632623

Review-Url: https://codereview.chromium.org/2327993002
Cr-Commit-Position: refs/heads/master@{#418767}

content/renderer/presentation/presentation_connection_client.cc

@@ -6,24 +6,25 @@
 
 #include "base/logging.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/WebURL.h"
 
 namespace content {
 
 PresentationConnectionClient::PresentationConnectionClient(
     blink::mojom::PresentationSessionInfoPtr session_info)
-    : url_(blink::WebString::fromUTF8(session_info->url.spec())),
+    : url_(session_info->url),
       id_(blink::WebString::fromUTF8(session_info->id)) {}
 
 PresentationConnectionClient::PresentationConnectionClient(
     const GURL& url,
     const mojo::String& id)
-    : url_(blink::WebString::fromUTF8(url.spec())),
+    : url_(url),
       id_(blink::WebString::fromUTF8(id)) {}
 
 PresentationConnectionClient::~PresentationConnectionClient() {
 }
 
-blink::WebString PresentationConnectionClient::getUrl() {
+blink::WebURL PresentationConnectionClient::getUrl() {
     return url_;
 }
 

content/renderer/presentation/presentation_connection_client.h

@@ -25,11 +25,11 @@ class CONTENT_EXPORT PresentationConnectionClient
   ~PresentationConnectionClient() override;
 
   // WebPresentationConnectionClient implementation.
-  blink::WebString getUrl() override;
+  blink::WebURL getUrl() override;
   blink::WebString getId() override;
 
  private:
-  blink::WebString url_;
+  blink::WebURL url_;
   blink::WebString id_;
 };
 

content/renderer/presentation/presentation_dispatcher.cc

@@ -4,7 +4,6 @@
 
 #include "content/renderer/presentation/presentation_dispatcher.h"
 
-#include <algorithm>
 #include <utility>
 #include <vector>
 
@@ -16,6 +15,7 @@
 #include "content/renderer/presentation/presentation_connection_client.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationAvailabilityObserver.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationController.h"
@@ -100,14 +100,14 @@ void PresentationDispatcher::setController(
 }
 
 void PresentationDispatcher::startSession(
-    const blink::WebVector<blink::WebString>& presentationUrls,
+    const blink::WebVector<blink::WebURL>& presentationUrls,
     blink::WebPresentationConnectionClientCallbacks* callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
-  std::vector<GURL> urls(presentationUrls.size());
-  std::transform(presentationUrls.begin(), presentationUrls.end(), urls.begin(),
-                 [](const blink::WebString& url) { return GURL(url.utf8()); });
+  std::vector<GURL> urls;
+  for (const auto& url : presentationUrls)
+    urls.push_back(url);
 
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
@@ -118,15 +118,15 @@ void PresentationDispatcher::startSession(
 }
 
 void PresentationDispatcher::joinSession(
-    const blink::WebVector<blink::WebString>& presentationUrls,
+    const blink::WebVector<blink::WebURL>& presentationUrls,
     const blink::WebString& presentationId,
     blink::WebPresentationConnectionClientCallbacks* callback) {
   DCHECK(callback);
   ConnectToPresentationServiceIfNeeded();
 
-  std::vector<GURL> urls(presentationUrls.size());
-  std::transform(presentationUrls.begin(), presentationUrls.end(), urls.begin(),
-                 [](const blink::WebString& url) { return GURL(url.utf8()); });
+  std::vector<GURL> urls;
+  for (const auto& url : presentationUrls)
+    urls.push_back(url);
 
   // The dispatcher owns the service so |this| will be valid when
   // OnSessionCreated() is called. |callback| needs to be alive and also needs
@@ -137,10 +137,9 @@ void PresentationDispatcher::joinSession(
                  base::Unretained(this), base::Owned(callback)));
 }
 
-void PresentationDispatcher::sendString(
-    const blink::WebString& presentationUrl,
-    const blink::WebString& presentationId,
-    const blink::WebString& message) {
+void PresentationDispatcher::sendString(const blink::WebURL& presentationUrl,
+                                        const blink::WebString& presentationId,
+                                        const blink::WebString& message) {
   if (message.utf8().size() > kMaxPresentationSessionMessageSize) {
     // TODO(crbug.com/459008): Limit the size of individual messages to 64k
     // for now. Consider throwing DOMException or splitting bigger messages
@@ -157,7 +156,7 @@ void PresentationDispatcher::sendString(
 }
 
 void PresentationDispatcher::sendArrayBuffer(
-    const blink::WebString& presentationUrl,
+    const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length) {
@@ -177,7 +176,7 @@ void PresentationDispatcher::sendArrayBuffer(
 }
 
 void PresentationDispatcher::sendBlobData(
-    const blink::WebString& presentationUrl,
+    const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const uint8_t* data,
     size_t length) {
@@ -227,30 +226,28 @@ void PresentationDispatcher::HandleSendMessageRequests(bool success) {
 }
 
 void PresentationDispatcher::closeSession(
-    const blink::WebString& presentationUrl,
+    const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
-  presentation_service_->CloseConnection(GURL(presentationUrl.utf8()),
+  presentation_service_->CloseConnection(presentationUrl,
                                          presentationId.utf8());
 }
 
 void PresentationDispatcher::terminateSession(
-    const blink::WebString& presentationUrl,
+    const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId) {
   ConnectToPresentationServiceIfNeeded();
-  presentation_service_->Terminate(GURL(presentationUrl.utf8()),
-                                   presentationId.utf8());
+  presentation_service_->Terminate(presentationUrl, presentationId.utf8());
 }
 
 void PresentationDispatcher::getAvailability(
-    const blink::WebString& availabilityUrl,
+    const blink::WebURL& availabilityUrl,
     blink::WebPresentationAvailabilityCallbacks* callbacks) {
-  const std::string& availability_url = availabilityUrl.utf8();
   AvailabilityStatus* status = nullptr;
-  auto status_it = availability_status_.find(availability_url);
+  auto status_it = availability_status_.find(availabilityUrl);
   if (status_it == availability_status_.end()) {
-    status = new AvailabilityStatus(availability_url);
-    availability_status_[availability_url] = base::WrapUnique(status);
+    status = new AvailabilityStatus(availabilityUrl);
+    availability_status_[availabilityUrl] = base::WrapUnique(status);
   } else {
     status = status_it->second.get();
   }
@@ -268,11 +265,10 @@ void PresentationDispatcher::getAvailability(
 
 void PresentationDispatcher::startListening(
     blink::WebPresentationAvailabilityObserver* observer) {
-  const std::string& availability_url = observer->url().string().utf8();
-  auto status_it = availability_status_.find(availability_url);
+  auto status_it = availability_status_.find(observer->url());
   if (status_it == availability_status_.end()) {
     DLOG(WARNING) << "Start listening for availability for unknown URL "
-                  << availability_url;
+                  << observer->url();
     return;
   }
   status_it->second->availability_observers.insert(observer);
@@ -281,11 +277,10 @@ void PresentationDispatcher::startListening(
 
 void PresentationDispatcher::stopListening(
     blink::WebPresentationAvailabilityObserver* observer) {
-  const std::string& availability_url = observer->url().string().utf8();
-  auto status_it = availability_status_.find(availability_url);
+  auto status_it = availability_status_.find(observer->url());
   if (status_it == availability_status_.end()) {
     DLOG(WARNING) << "Stop listening for availability for unknown URL "
-                  << availability_url;
+                  << observer->url();
     return;
   }
   status_it->second->availability_observers.erase(observer);
@@ -293,12 +288,13 @@ void PresentationDispatcher::stopListening(
 }
 
 void PresentationDispatcher::setDefaultPresentationUrls(
-    const blink::WebVector<blink::WebString>& presentationUrls) {
+    const blink::WebVector<blink::WebURL>& presentationUrls) {
   ConnectToPresentationServiceIfNeeded();
 
-  std::vector<GURL> urls(presentationUrls.size());
-  std::transform(presentationUrls.begin(), presentationUrls.end(), urls.begin(),
-                 [](const blink::WebString& url) { return GURL(url.utf8()); });
+  std::vector<GURL> urls;
+  for (const auto& url : presentationUrls)
+    urls.push_back(url);
+
   presentation_service_->SetDefaultPresentationUrls(urls);
 }
 
@@ -321,7 +317,7 @@ void PresentationDispatcher::OnDestruct() {
 
 void PresentationDispatcher::OnScreenAvailabilityUpdated(const GURL& url,
                                                          bool available) {
-  auto status_it = availability_status_.find(url.spec());
+  auto status_it = availability_status_.find(url);
   if (status_it == availability_status_.end())
     return;
   AvailabilityStatus* status = status_it->second.get();
@@ -343,7 +339,7 @@ void PresentationDispatcher::OnScreenAvailabilityUpdated(const GURL& url,
 }
 
 void PresentationDispatcher::OnScreenAvailabilityNotSupported(const GURL& url) {
-  auto status_it = availability_status_.find(url.spec());
+  auto status_it = availability_status_.find(url);
   if (status_it == availability_status_.end())
     return;
   AvailabilityStatus* status = status_it->second.get();
@@ -475,11 +471,10 @@ void PresentationDispatcher::UpdateListeningState(AvailabilityStatus* status) {
   ConnectToPresentationServiceIfNeeded();
   if (should_listen) {
     status->listening_state = ListeningState::WAITING;
-    presentation_service_->ListenForScreenAvailability(GURL(status->url));
+    presentation_service_->ListenForScreenAvailability(status->url);
   } else {
     status->listening_state = ListeningState::INACTIVE;
-    presentation_service_->StopListeningForScreenAvailability(
-        GURL(status->url));
+    presentation_service_->StopListeningForScreenAvailability(status->url);
   }
 }
 
@@ -493,12 +488,12 @@ PresentationDispatcher::SendMessageRequest::~SendMessageRequest() {}
 // static
 PresentationDispatcher::SendMessageRequest*
 PresentationDispatcher::CreateSendTextMessageRequest(
-    const blink::WebString& presentationUrl,
+    const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     const blink::WebString& message) {
   blink::mojom::PresentationSessionInfoPtr session_info =
       blink::mojom::PresentationSessionInfo::New();
-  session_info->url = GURL(presentationUrl.utf8());
+  session_info->url = presentationUrl;
   session_info->id = presentationId.utf8();
 
   blink::mojom::SessionMessagePtr session_message =
@@ -512,14 +507,14 @@ PresentationDispatcher::CreateSendTextMessageRequest(
 // static
 PresentationDispatcher::SendMessageRequest*
 PresentationDispatcher::CreateSendBinaryMessageRequest(
-    const blink::WebString& presentationUrl,
+    const blink::WebURL& presentationUrl,
     const blink::WebString& presentationId,
     blink::mojom::PresentationMessageType type,
     const uint8_t* data,
     size_t length) {
   blink::mojom::PresentationSessionInfoPtr session_info =
       blink::mojom::PresentationSessionInfo::New();
-  session_info->url = GURL(presentationUrl.utf8());
+  session_info->url = presentationUrl;
   session_info->id = presentationId.utf8();
 
   blink::mojom::SessionMessagePtr session_message =
@@ -531,7 +526,7 @@ PresentationDispatcher::CreateSendBinaryMessageRequest(
 }
 
 PresentationDispatcher::AvailabilityStatus::AvailabilityStatus(
-    const std::string& availability_url)
+    const GURL& availability_url)
     : url(availability_url),
       last_known_availability(false),
       listening_state(ListeningState::INACTIVE) {}

content/renderer/presentation/presentation_dispatcher.h

@@ -20,10 +20,12 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "third_party/WebKit/public/platform/modules/presentation/WebPresentationClient.h"
 #include "third_party/WebKit/public/platform/modules/presentation/presentation.mojom.h"
+#include "url/gurl.h"
 
 namespace blink {
 class WebPresentationAvailabilityObserver;
 class WebString;
+class WebURL;
 template <typename T>
 class WebVector;
 }  // namespace blink
@@ -51,11 +53,11 @@ class CONTENT_EXPORT PresentationDispatcher
   };
 
   static SendMessageRequest* CreateSendTextMessageRequest(
-      const blink::WebString& presentationUrl,
+      const blink::WebURL& presentationUrl,
       const blink::WebString& presentationId,
       const blink::WebString& message);
   static SendMessageRequest* CreateSendBinaryMessageRequest(
-      const blink::WebString& presentationUrl,
+      const blink::WebURL& presentationUrl,
       const blink::WebString& presentationId,
       blink::mojom::PresentationMessageType type,
       const uint8_t* data,
@@ -64,34 +66,34 @@ class CONTENT_EXPORT PresentationDispatcher
   // WebPresentationClient implementation.
   void setController(blink::WebPresentationController* controller) override;
   void startSession(
-      const blink::WebVector<blink::WebString>& presentationUrls,
+      const blink::WebVector<blink::WebURL>& presentationUrls,
       blink::WebPresentationConnectionClientCallbacks* callback) override;
   void joinSession(
-      const blink::WebVector<blink::WebString>& presentationUrls,
+      const blink::WebVector<blink::WebURL>& presentationUrls,
       const blink::WebString& presentationId,
       blink::WebPresentationConnectionClientCallbacks* callback) override;
-  void sendString(const blink::WebString& presentationUrl,
+  void sendString(const blink::WebURL& presentationUrl,
                   const blink::WebString& presentationId,
                   const blink::WebString& message) override;
-  void sendArrayBuffer(const blink::WebString& presentationUrl,
+  void sendArrayBuffer(const blink::WebURL& presentationUrl,
                        const blink::WebString& presentationId,
                        const uint8_t* data,
                        size_t length) override;
-  void sendBlobData(const blink::WebString& presentationUrl,
+  void sendBlobData(const blink::WebURL& presentationUrl,
                     const blink::WebString& presentationId,
                     const uint8_t* data,
                     size_t length) override;
-  void closeSession(const blink::WebString& presentationUrl,
+  void closeSession(const blink::WebURL& presentationUrl,
                     const blink::WebString& presentationId) override;
-  void terminateSession(const blink::WebString& presentationUrl,
+  void terminateSession(const blink::WebURL& presentationUrl,
                         const blink::WebString& presentationId) override;
   void getAvailability(
-      const blink::WebString& availabilityUrl,
+      const blink::WebURL& availabilityUrl,
       blink::WebPresentationAvailabilityCallbacks* callbacks) override;
   void startListening(blink::WebPresentationAvailabilityObserver*) override;
   void stopListening(blink::WebPresentationAvailabilityObserver*) override;
   void setDefaultPresentationUrls(
-      const blink::WebVector<blink::WebString>& presentationUrls) override;
+      const blink::WebVector<blink::WebURL>& presentationUrls) override;
 
   // RenderFrameObserver implementation.
   void DidCommitProvisionalLoad(
@@ -153,17 +155,18 @@ class CONTENT_EXPORT PresentationDispatcher
 
   // Tracks status of presentation displays availability for |availability_url|.
   struct AvailabilityStatus {
-    explicit AvailabilityStatus(const std::string& availability_url);
+    explicit AvailabilityStatus(const GURL& availability_url);
     ~AvailabilityStatus();
 
-    const std::string url;
+    const GURL url;
     bool last_known_availability;
     ListeningState listening_state;
     AvailabilityCallbacksMap availability_callbacks;
     AvailabilityObserversSet availability_observers;
   };
 
-  std::map<std::string, std::unique_ptr<AvailabilityStatus>>
+  // Map of AvailabilityStatus for known URLs.
+  std::map<GURL, std::unique_ptr<AvailabilityStatus>>
       availability_status_;
 
   // Updates the listening state of availability for |status| and notifies the

third_party/WebKit/Source/modules/presentation/PresentationConnection.cpp

@@ -157,7 +157,7 @@ private:
     std::unique_ptr<FileReaderLoader> m_loader;
 };
 
-PresentationConnection::PresentationConnection(LocalFrame* frame, const String& id, const String& url)
+PresentationConnection::PresentationConnection(LocalFrame* frame, const String& id, const KURL& url)
     : DOMWindowProperty(frame)
     , m_id(id)
     , m_url(url)
@@ -406,7 +406,7 @@ void PresentationConnection::terminate()
 
 bool PresentationConnection::matches(WebPresentationConnectionClient* client) const
 {
-    return client && m_url == static_cast<String>(client->getUrl()) && m_id == static_cast<String>(client->getId());
+    return client && m_url == KURL(client->getUrl()) && m_id == static_cast<String>(client->getId());
 }
 
 void PresentationConnection::didChangeState(WebPresentationConnectionState state)

third_party/WebKit/Source/modules/presentation/PresentationConnection.h

@@ -10,6 +10,7 @@
 #include "core/fileapi/FileError.h"
 #include "core/frame/DOMWindowProperty.h"
 #include "platform/heap/Handle.h"
+#include "platform/weborigin/KURL.h"
 #include "public/platform/modules/presentation/WebPresentationConnectionClient.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
@@ -97,7 +98,7 @@ private:
 
     class Message;
 
-    PresentationConnection(LocalFrame*, const String& id, const String& url);
+    PresentationConnection(LocalFrame*, const String& id, const KURL&);
 
     bool canSendMessage(ExceptionState&);
     void handleMessageQueue();
@@ -110,7 +111,7 @@ private:
     void tearDown();
 
     String m_id;
-    String m_url;
+    KURL m_url;
     WebPresentationConnectionState m_state;
 
     // For Blob data handling.

third_party/WebKit/Source/modules/presentation/PresentationController.cpp

@@ -121,9 +121,9 @@ void PresentationController::setDefaultRequestUrl(const KURL& url)
         return;
 
     // TODO(crbug.com/627655): Accept multiple URLs per PresentationRequest.
-    WebVector<WebString> presentationUrls(static_cast<size_t>(1));
+    WebVector<WebURL> presentationUrls(static_cast<size_t>(1));
     if (url.isValid())
-        presentationUrls[0] = url.getString();
+        presentationUrls[0] = url;
 
     m_client->setDefaultPresentationUrls(presentationUrls);
 }

third_party/WebKit/Source/modules/presentation/PresentationReceiverTest.cpp

@@ -9,6 +9,7 @@
 #include "core/frame/LocalFrame.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/presentation/PresentationConnectionList.h"
+#include "platform/testing/URLTestHelpers.h"
 #include "public/platform/modules/presentation/WebPresentationConnectionClient.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -34,7 +35,7 @@ public:
 class TestWebPresentationConnectionClient : public WebPresentationConnectionClient {
 public:
     WebString getId() override { return WebString::fromUTF8("id"); }
-    WebString getUrl() override { return WebString::fromUTF8("url"); }
+    WebURL getUrl() override { return URLTestHelpers::toKURL("http://www.example.com"); }
 };
 
 class PresentationReceiverTest : public ::testing::Test {

third_party/WebKit/Source/modules/presentation/PresentationRequest.cpp

@@ -106,8 +106,8 @@ ScriptPromise PresentationRequest::start(ScriptState* scriptState)
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     // TODO(crbug.com/627655): Accept multiple URLs per PresentationRequest.
-    WebVector<WebString> presentationUrls(static_cast<size_t>(1U));
-    presentationUrls[0] = m_url.getString();
+    WebVector<WebURL> presentationUrls(static_cast<size_t>(1U));
+    presentationUrls[0] = m_url;
     client->startSession(presentationUrls, new PresentationConnectionCallbacks(resolver, this));
     return resolver->promise();
 }
@@ -123,8 +123,8 @@ ScriptPromise PresentationRequest::reconnect(ScriptState* scriptState, const Str
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     // TODO(crbug.com/627655): Accept multiple URLs per PresentationRequest.
-    WebVector<WebString> presentationUrls(static_cast<size_t>(1U));
-    presentationUrls[0] = m_url.getString();
+    WebVector<WebURL> presentationUrls(static_cast<size_t>(1U));
+    presentationUrls[0] = m_url;
     client->joinSession(presentationUrls, id, new PresentationConnectionCallbacks(resolver, this));
     return resolver->promise();
 }
@@ -139,7 +139,7 @@ ScriptPromise PresentationRequest::getAvailability(ScriptState* scriptState)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "The PresentationRequest is no longer associated to a frame."));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
-    client->getAvailability(m_url.getString(), new PresentationAvailabilityCallbacks(resolver, m_url));
+    client->getAvailability(m_url, new PresentationAvailabilityCallbacks(resolver, m_url));
     return resolver->promise();
 }
 

third_party/WebKit/public/platform/modules/presentation/WebPresentationClient.h

@@ -16,6 +16,7 @@ class WebPresentationAvailabilityObserver;
 class WebPresentationController;
 class WebPresentationConnectionClient;
 class WebString;
+class WebURL;
 struct WebPresentationError;
 template <typename T>
 class WebVector;
@@ -29,7 +30,6 @@ using WebPresentationConnectionClientCallbacks = WebCallbacks<std::unique_ptr<We
 using WebPresentationAvailabilityCallbacks = WebCallbacks<bool, const WebPresentationError&>;
 
 // The implementation the embedder has to provide for the Presentation API to work.
-// TODO(crbug.com/632623): Use WebURL instead of WebString in this API.
 class WebPresentationClient {
 public:
     virtual ~WebPresentationClient() { }
@@ -39,34 +39,34 @@ public:
 
     // Called when the frame requests to start a new session.
     // The ownership of the |callbacks| argument is transferred to the embedder.
-    virtual void startSession(const WebVector<WebString>& presentationUrls, WebPresentationConnectionClientCallbacks*) = 0;
+    virtual void startSession(const WebVector<WebURL>& presentationUrls, WebPresentationConnectionClientCallbacks*) = 0;
 
     // Called when the frame requests to join an existing session.
     // The ownership of the |callbacks| argument is transferred to the embedder.
-    virtual void joinSession(const WebVector<WebString>& presentationUrls, const WebString& presentationId, WebPresentationConnectionClientCallbacks*) = 0;
+    virtual void joinSession(const WebVector<WebURL>& presentationUrls, const WebString& presentationId, WebPresentationConnectionClientCallbacks*) = 0;
 
     // Called when the frame requests to send String message to an existing session.
 
-    virtual void sendString(const WebString& presentationUrl, const WebString& presentationId, const WebString& message) = 0;
+    virtual void sendString(const WebURL& presentationUrl, const WebString& presentationId, const WebString& message) = 0;
 
     // Called when the frame requests to send ArrayBuffer/View data to an existing session.
     // Embedder copies the |data| and the ownership is not transferred.
-    virtual void sendArrayBuffer(const WebString& presentationUrl, const WebString& presentationId, const uint8_t* data, size_t length) = 0;
+    virtual void sendArrayBuffer(const WebURL& presentationUrl, const WebString& presentationId, const uint8_t* data, size_t length) = 0;
 
     // Called when the frame requests to send Blob data to an existing session.
     // Embedder copies the |data| and the ownership is not transferred.
-    virtual void sendBlobData(const WebString& presentationUrl, const WebString& presentationId, const uint8_t* data, size_t length) = 0;
+    virtual void sendBlobData(const WebURL& presentationUrl, const WebString& presentationId, const uint8_t* data, size_t length) = 0;
 
     // Called when the frame requests to close an existing session.
-    virtual void closeSession(const WebString& presentationUrl, const WebString& presentationId) = 0;
+    virtual void closeSession(const WebURL& presentationUrl, const WebString& presentationId) = 0;
 
     // Called when the frame requests to terminate an existing session.
-    virtual void terminateSession(const WebString& presentationUrl, const WebString& presentationId) = 0;
+    virtual void terminateSession(const WebURL& presentationUrl, const WebString& presentationId) = 0;
 
     // Called when the frame wants to know the availability of a presentation
     // display for |availabilityUrl|.  The ownership of the callbacks argument
     // is transferred to the embedder.
-    virtual void getAvailability(const WebString& availabilityUrl, WebPresentationAvailabilityCallbacks*) = 0;
+    virtual void getAvailability(const WebURL& availabilityUrl, WebPresentationAvailabilityCallbacks*) = 0;
 
     // Start listening to changes in presentation displays availability. The
     // observer will be notified in case of a change. The observer is
@@ -79,7 +79,7 @@ public:
 
     // Called when a defaultRequest has been set. It sends the url associated
     // with it for the embedder.
-    virtual void setDefaultPresentationUrls(const WebVector<WebString>&) = 0;
+    virtual void setDefaultPresentationUrls(const WebVector<WebURL>&) = 0;
 };
 
 } // namespace blink

third_party/WebKit/public/platform/modules/presentation/WebPresentationConnectionClient.h

@@ -6,6 +6,7 @@
 #define WebPresentationConnectionClient_h
 
 #include "public/platform/WebString.h"
+#include "public/platform/WebURL.h"
 
 namespace blink {
 
@@ -27,7 +28,7 @@ public:
     virtual ~WebPresentationConnectionClient() { }
 
     virtual WebString getId() = 0;
-    virtual WebString getUrl() = 0;
+    virtual WebURL getUrl() = 0;
 };
 
 } // namespace blink