Move GetDocument method from WebFrame to WebLocalFrame.

content/renderer/media/peer_connection_tracker.cc

 // Copyright (c) 2013 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 "content/renderer/media/peer_connection_tracker.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
+#include <string>
 #include <utility>
+#include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebRTCAnswerOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCICECandidate.h"
 #include "third_party/WebKit/public/platform/WebRTCOfferOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
 
 using webrtc::MediaConstraintsInterface;
 using webrtc::StatsReport;
 using webrtc::StatsReports;
 using blink::WebRTCPeerConnectionHandlerClient;
 
 namespace content {
 
 // TODO(hta): This module should be redesigned to reduce string copies.
@@ skipping 88 matching lines @@
     transport_type = "relay";
     break;
   case webrtc::PeerConnectionInterface::kAll:
     transport_type = "all";
     break;
   case webrtc::PeerConnectionInterface::kNoHost:
     transport_type = "noHost";
     break;
   default:
     NOTREACHED();
-  };
+  }
   return transport_type;
 }
 
 static const char* SerializeBundlePolicy(
     webrtc::PeerConnectionInterface::BundlePolicy policy) {
   const char* policy_str = "";
   switch (policy) {
   case webrtc::PeerConnectionInterface::kBundlePolicyBalanced:
     policy_str = "balanced";
     break;
   case webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle:
     policy_str = "max-bundle";
     break;
   case webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat:
     policy_str = "max-compat";
     break;
   default:
     NOTREACHED();
-  };
+  }
   return policy_str;
 }
 
 static const char* SerializeRtcpMuxPolicy(
     webrtc::PeerConnectionInterface::RtcpMuxPolicy policy) {
   const char* policy_str = "";
   switch (policy) {
   case webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate:
     policy_str = "negotiate";
     break;
   case webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire:
     policy_str = "require";
     break;
   default:
     NOTREACHED();
-  };
+  }
   return policy_str;
 }
 
 static std::string SerializeConfiguration(
     const webrtc::PeerConnectionInterface::RTCConfiguration& config) {
   std::ostringstream oss;
   // TODO(hbos): Add serialization of certificate.
   oss << "{ iceServers: " << SerializeServers(config.servers)
       << ", iceTransportPolicy: " << SerializeIceTransportType(config.type)
       << ", bundlePolicy: " << SerializeBundlePolicy(config.bundle_policy)
@@ skipping 120 matching lines @@
   auto result = base::MakeUnique<base::DictionaryValue>();
   result->Set("stats", std::move(stats));
   result->SetString("id", report.id()->ToString());
   result->SetString("type", report.TypeToString());
 
   return result;
 }
 
 class InternalStatsObserver : public webrtc::StatsObserver {
  public:
-  InternalStatsObserver(int lid)
+  explicit InternalStatsObserver(int lid)
       : lid_(lid), main_thread_(base::ThreadTaskRunnerHandle::Get()) {}
 
   void OnComplete(const StatsReports& reports) override {
     std::unique_ptr<base::ListValue> list(new base::ListValue());
 
     for (const auto* r : reports) {
       std::unique_ptr<base::DictionaryValue> report = GetDictValue(*r);
       if (report)
         list->Append(std::move(report));
     }
@@ skipping 103 matching lines @@
       it.first->StopEventLog();
       return;
     }
   }
 }
 
 void PeerConnectionTracker::RegisterPeerConnection(
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const blink::WebMediaConstraints& constraints,
-    const blink::WebFrame* frame) {
+    const blink::WebLocalFrame* frame) {
   DCHECK(main_thread_.CalledOnValidThread());
   DCHECK_EQ(GetLocalIDForHandler(pc_handler), -1);
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
   info.rtc_configuration = SerializeConfiguration(config);
 
   info.constraints = SerializeMediaConstraints(constraints);
   if (frame)
@@ skipping 131 matching lines @@
   if (id == -1)
     return;
   SendPeerConnectionUpdate(
       id, source == SOURCE_LOCAL ? "addStream" : "onAddStream",
       SerializeMediaDescriptor(stream));
 }
 
 void PeerConnectionTracker::TrackRemoveStream(
     RTCPeerConnectionHandler* pc_handler,
     const blink::WebMediaStream& stream,
-    Source source){
+    Source source) {
   DCHECK(main_thread_.CalledOnValidThread());
   int id = GetLocalIDForHandler(pc_handler);
   if (id == -1)
     return;
   SendPeerConnectionUpdate(
       id, source == SOURCE_LOCAL ? "removeStream" : "onRemoveStream",
       SerializeMediaDescriptor(stream));
 }
 
 void PeerConnectionTracker::TrackCreateDataChannel(
@@ skipping 141 matching lines @@
   DCHECK(main_thread_.CalledOnValidThread());
   SendTarget()->Send(new PeerConnectionTrackerHost_UpdatePeerConnection(
       local_id, std::string(callback_type), value));
 }
 
 void PeerConnectionTracker::OverrideSendTargetForTesting(RenderThread* target) {
   send_target_for_test_ = target;
 }
 
 }  // namespace content