[chrome.displaySource] Switch mojom targets to use STL types.

extensions/renderer/api/display_source/wifi_display/wifi_display_session.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 "extensions/renderer/api/display_source/wifi_display/wifi_display_session.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/timer/timer.h"
@@ skipping 56 matching lines @@
   state_ = DisplaySourceSession::Establishing;
   start_completion_callback_ = callback;
 }
 
 void WiFiDisplaySession::Terminate(const CompletionCallback& callback) {
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   Terminate();
   teminate_completion_callback_ = callback;
 }
 
-void WiFiDisplaySession::OnConnected(const mojo::String& local_ip_address,
-                                     const mojo::String& sink_ip_address) {
+void WiFiDisplaySession::OnConnected(const std::string& local_ip_address,
+                                     const std::string& sink_ip_address) {
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   local_ip_address_ = local_ip_address;
   media_manager_.reset(
       new WiFiDisplayMediaManager(
           params_.video_track,
           params_.audio_track,
           sink_ip_address,
           params_.render_frame->GetRemoteInterfaces(),
           base::Bind(
               &WiFiDisplaySession::OnMediaError,
               weak_factory_.GetWeakPtr())));
   wfd_source_.reset(wds::Source::Create(this, media_manager_.get(), this));
   wfd_source_->Start();
 }
 
 void WiFiDisplaySession::OnConnectRequestHandled(bool success,
-                                                 const mojo::String& error) {
+                                                 const std::string& error) {
   DCHECK_EQ(DisplaySourceSession::Establishing, state_);
   state_ =
       success ? DisplaySourceSession::Established : DisplaySourceSession::Idle;
   RunStartCallback(success, error);
 }
 
 void WiFiDisplaySession::OnTerminated() {
   DCHECK_NE(DisplaySourceSession::Idle, state_);
   state_ = DisplaySourceSession::Idle;
   media_manager_.reset();
   wfd_source_.reset();
   terminated_callback_.Run();
 }
 
 void WiFiDisplaySession::OnDisconnectRequestHandled(bool success,
-                                                    const mojo::String& error) {
+                                                    const std::string& error) {
   RunTerminateCallback(success, error);
 }
 
-void WiFiDisplaySession::OnError(int32_t type,
-                                 const mojo::String& description) {
+void WiFiDisplaySession::OnError(int32_t type, const std::string& description) {
   DCHECK(type > api::display_source::ERROR_TYPE_NONE
          && type <= api::display_source::ERROR_TYPE_LAST);
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   error_callback_.Run(static_cast<ErrorType>(type), description);
 }
 
-void WiFiDisplaySession::OnMessage(const mojo::String& data) {
+void WiFiDisplaySession::OnMessage(const std::string& data) {
   DCHECK_EQ(DisplaySourceSession::Established, state_);
   DCHECK(wfd_source_);
   wfd_source_->RTSPDataReceived(data);
 }
 
 std::string WiFiDisplaySession::GetLocalIPAddress() const {
   return local_ip_address_;
 }
 
 int WiFiDisplaySession::GetNextCSeq(int* initial_peer_cseq) const {
@@ skipping 83 matching lines @@
 }
 
 void WiFiDisplaySession::RunTerminateCallback(
     bool success,
     const std::string& error_message) {
   if (!teminate_completion_callback_.is_null())
     teminate_completion_callback_.Run(success, error_message);
 }
 
 }  // namespace extensions