Move //components/test_runner back into //content/shell

content/shell/test_runner/mock_webrtc_peer_connection_handler.cc

 // Copyright 2014 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 "components/test_runner/mock_webrtc_peer_connection_handler.h"
+#include "content/shell/test_runner/mock_webrtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "components/test_runner/mock_webrtc_data_channel_handler.h"
-#include "components/test_runner/mock_webrtc_dtmf_sender_handler.h"
-#include "components/test_runner/test_interfaces.h"
-#include "components/test_runner/web_test_delegate.h"
+#include "content/shell/test_runner/mock_webrtc_data_channel_handler.h"
+#include "content/shell/test_runner/mock_webrtc_dtmf_sender_handler.h"
+#include "content/shell/test_runner/test_interfaces.h"
+#include "content/shell/test_runner/web_test_delegate.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/WebRTCDataChannelInit.h"
 #include "third_party/WebKit/public/platform/WebRTCOfferOptions.h"
 #include "third_party/WebKit/public/platform/WebRTCPeerConnectionHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebRTCStatsResponse.h"
 #include "third_party/WebKit/public/platform/WebRTCVoidRequest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
@@ skipping 34 matching lines @@
       NOTREACHED();
       return 0.0f;
     }
     blink::WebString valueString() const override {
       return blink::WebString::fromUTF8((*values_)[i].second);
     }
     bool valueBool() const override {
       NOTREACHED();
       return false;
     }
-    blink::WebString valueToString() const override {
-      return valueString();
-    }
+    blink::WebString valueToString() const override { return valueString(); }
 
    private:
     size_t i = 0;
     const std::vector<std::pair<std::string, std::string>>* values_;
   };
 
   MockWebRTCLegacyStats(const char* id, const char* type_name, double timestamp)
       : id_(id), type_name_(type_name), timestamp_(timestamp) {}
 
   // blink::WebRTCLegacyStats
   blink::WebString id() const override {
     return blink::WebString::fromUTF8(id_);
   }
   blink::WebString type() const override {
     return blink::WebString::fromUTF8(type_name_);
   }
-  double timestamp() const override {
-    return timestamp_;
-  }
+  double timestamp() const override { return timestamp_; }
   blink::WebRTCLegacyStatsMemberIterator* iterator() const override {
     return new MemberIterator(&values_);
   }
 
   void addStatistic(const std::string& name, const std::string& value) {
     values_.push_back(std::make_pair(name, value));
   }
 
  private:
   const std::string id_;
   const std::string type_name_;
   const double timestamp_;
   // (name, value) pairs.
   std::vector<std::pair<std::string, std::string>> values_;
 };
 
-template<typename T>
+template <typename T>
 WebVector<T> sequenceWithValue(T value) {
   return WebVector<T>(&value, 1);
 }
 
 class MockWebRTCStatsMember : public blink::WebRTCStatsMember {
  public:
-  MockWebRTCStatsMember(
-      const std::string& name, blink::WebRTCStatsMemberType type)
+  MockWebRTCStatsMember(const std::string& name,
+                        blink::WebRTCStatsMemberType type)
       : name_(name), type_(type) {}
 
   // blink::WebRTCStatsMember overrides.
   blink::WebString name() const override {
     return blink::WebString::fromUTF8(name_);
   }
-  blink::WebRTCStatsMemberType type() const override {
-    return type_;
-  }
+  blink::WebRTCStatsMemberType type() const override { return type_; }
   bool isDefined() const override { return true; }
   bool valueBool() const override { return true; }
   int32_t valueInt32() const override { return 42; }
   uint32_t valueUint32() const override { return 42; }
   int64_t valueInt64() const override { return 42; }
   uint64_t valueUint64() const override { return 42; }
   double valueDouble() const override { return 42.0; }
   blink::WebString valueString() const override {
     return blink::WebString::fromUTF8("42");
   }
@@ skipping 20 matching lines @@
         blink::WebString::fromUTF8("42"));
   }
 
  private:
   std::string name_;
   blink::WebRTCStatsMemberType type_;
 };
 
 class MockWebRTCStats : public blink::WebRTCStats {
  public:
-  MockWebRTCStats(
-      const std::string& id, const std::string& type, double timestamp)
-      : id_(id), type_(type), timestamp_(timestamp) {
-  }
+  MockWebRTCStats(const std::string& id,
+                  const std::string& type,
+                  double timestamp)
+      : id_(id), type_(type), timestamp_(timestamp) {}
 
   void addMember(const std::string& name, blink::WebRTCStatsMemberType type) {
     members_.push_back(std::make_pair(name, type));
   }
 
   // blink::WebRTCStats overrides.
   blink::WebString id() const override {
     return blink::WebString::fromUTF8(id_);
   }
   blink::WebString type() const override {
     return blink::WebString::fromUTF8(type_);
   }
-  double timestamp() const override {
-    return timestamp_;
-  }
-  size_t membersCount() const override {
-    return members_.size();
-  }
+  double timestamp() const override { return timestamp_; }
+  size_t membersCount() const override { return members_.size(); }
   std::unique_ptr<WebRTCStatsMember> getMember(size_t i) const override {
-    return std::unique_ptr<WebRTCStatsMember>(new MockWebRTCStatsMember(
-        members_[i].first, members_[i].second));
+    return std::unique_ptr<WebRTCStatsMember>(
+        new MockWebRTCStatsMember(members_[i].first, members_[i].second));
   }
 
  private:
   std::string id_;
   std::string type_;
   double timestamp_;
   std::vector<std::pair<std::string, blink::WebRTCStatsMemberType>> members_;
 };
 
 class MockWebRTCStatsReport : public blink::WebRTCStatsReport {
  public:
   MockWebRTCStatsReport() : i_(0) {}
   MockWebRTCStatsReport(const MockWebRTCStatsReport& other)
       : stats_(other.stats_), i_(0) {}
 
-  void AddStats(const MockWebRTCStats& stats) {
-    stats_.push_back(stats);
-  }
+  void AddStats(const MockWebRTCStats& stats) { stats_.push_back(stats); }
 
   // blink::WebRTCStatsReport overrides.
   std::unique_ptr<blink::WebRTCStatsReport> copyHandle() const override {
     // Because this is just a mock, we copy the underlying stats instead of
     // referencing the same stats as the original report.
     return std::unique_ptr<blink::WebRTCStatsReport>(
         new MockWebRTCStatsReport(*this));
   }
   std::unique_ptr<WebRTCStats> getStats(WebString id) const override {
     for (const MockWebRTCStats& stats : stats_) {
@@ skipping 12 matching lines @@
  private:
   std::vector<MockWebRTCStats> stats_;
   size_t i_;
 };
 
 }  // namespace
 
 MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler()
     : weak_factory_(this) {}
 
-MockWebRTCPeerConnectionHandler::~MockWebRTCPeerConnectionHandler() {
-}
+MockWebRTCPeerConnectionHandler::~MockWebRTCPeerConnectionHandler() {}
 
 MockWebRTCPeerConnectionHandler::MockWebRTCPeerConnectionHandler(
     WebRTCPeerConnectionHandlerClient* client,
     TestInterfaces* interfaces)
     : client_(client),
       stopped_(false),
       stream_count_(0),
       interfaces_(interfaces),
       weak_factory_(this) {}
 
@@ skipping 94 matching lines @@
     local_description_ = local_description;
     PostRequestResult(request);
   } else {
     PostRequestFailure(request);
   }
 }
 
 void MockWebRTCPeerConnectionHandler::setRemoteDescription(
     const WebRTCVoidRequest& request,
     const WebRTCSessionDescription& remote_description) {
-
   if (!remote_description.isNull() && remote_description.sdp() == "remote") {
     UpdateRemoteStreams();
     remote_description_ = remote_description;
     PostRequestResult(request);
   } else
     PostRequestFailure(request);
 }
 
 void MockWebRTCPeerConnectionHandler::UpdateRemoteStreams() {
   // Find all removed streams.
@@ skipping 34 matching lines @@
   while (added_it != local_streams_.end()) {
     if (remote_streams_.find(added_it->first) != remote_streams_.end()) {
       added_it++;
       continue;
     }
 
     const blink::WebMediaStream& stream = added_it->second;
 
     blink::WebVector<blink::WebMediaStreamTrack> local_audio_tracks;
     stream.audioTracks(local_audio_tracks);
-    blink::WebVector<blink::WebMediaStreamTrack>
-        remote_audio_tracks(local_audio_tracks.size());
+    blink::WebVector<blink::WebMediaStreamTrack> remote_audio_tracks(
+        local_audio_tracks.size());
 
     for (size_t i = 0; i < local_audio_tracks.size(); ++i) {
       blink::WebMediaStreamSource webkit_source;
       webkit_source.initialize(local_audio_tracks[i].id(),
                                blink::WebMediaStreamSource::TypeAudio,
-                               local_audio_tracks[i].id(),
-                               true /* remote */);
+                               local_audio_tracks[i].id(), true /* remote */);
       remote_audio_tracks[i].initialize(webkit_source);
     }
 
     blink::WebVector<blink::WebMediaStreamTrack> local_video_tracks;
     stream.videoTracks(local_video_tracks);
-    blink::WebVector<blink::WebMediaStreamTrack>
-        remote_video_tracks(local_video_tracks.size());
+    blink::WebVector<blink::WebMediaStreamTrack> remote_video_tracks(
+        local_video_tracks.size());
     for (size_t i = 0; i < local_video_tracks.size(); ++i) {
       blink::WebMediaStreamSource webkit_source;
       webkit_source.initialize(local_video_tracks[i].id(),
                                blink::WebMediaStreamSource::TypeVideo,
-                               local_video_tracks[i].id(),
-                               true /* remote */);
+                               local_video_tracks[i].id(), true /* remote */);
       remote_video_tracks[i].initialize(webkit_source);
     }
 
     blink::WebMediaStream new_remote_stream;
-    new_remote_stream.initialize(remote_audio_tracks,
-                                 remote_video_tracks);
+    new_remote_stream.initialize(remote_audio_tracks, remote_video_tracks);
     remote_streams_[added_it->first] = new_remote_stream;
     client_->didAddRemoteStream(new_remote_stream);
     ++added_it;
   }
 }
 
 WebRTCSessionDescription MockWebRTCPeerConnectionHandler::localDescription() {
   return local_description_;
 }
 
@@ skipping 75 matching lines @@
   stats.addMember("double", blink::WebRTCStatsMemberTypeDouble);
   stats.addMember("string", blink::WebRTCStatsMemberTypeString);
   stats.addMember("sequenceBool", blink::WebRTCStatsMemberTypeSequenceBool);
   stats.addMember("sequenceInt32", blink::WebRTCStatsMemberTypeSequenceInt32);
   stats.addMember("sequenceUint32", blink::WebRTCStatsMemberTypeSequenceUint32);
   stats.addMember("sequenceInt64", blink::WebRTCStatsMemberTypeSequenceInt64);
   stats.addMember("sequenceUint64", blink::WebRTCStatsMemberTypeSequenceUint64);
   stats.addMember("sequenceDouble", blink::WebRTCStatsMemberTypeSequenceDouble);
   stats.addMember("sequenceString", blink::WebRTCStatsMemberTypeSequenceString);
   report->AddStats(stats);
-  callback->OnStatsDelivered(std::unique_ptr<blink::WebRTCStatsReport>(
-      report.release()));
+  callback->OnStatsDelivered(
+      std::unique_ptr<blink::WebRTCStatsReport>(report.release()));
 }
 
 void MockWebRTCPeerConnectionHandler::ReportCreationOfDataChannel() {
   WebRTCDataChannelInit init;
   WebRTCDataChannelHandler* remote_data_channel =
       new MockWebRTCDataChannelHandler("MockRemoteDataChannel", init,
                                        interfaces_->GetDelegate());
   client_->didAddRemoteDataChannel(remote_data_channel);
 }
 
 WebRTCDataChannelHandler* MockWebRTCPeerConnectionHandler::createDataChannel(
     const WebString& label,
     const blink::WebRTCDataChannelInit& init) {
   interfaces_->GetDelegate()->PostTask(
       base::Bind(&MockWebRTCPeerConnectionHandler::ReportCreationOfDataChannel,
                  weak_factory_.GetWeakPtr()));
 
   // TODO(lukasza): Unclear if it is okay to return a different object than the
   // one created in ReportCreationOfDataChannel.
-  return new MockWebRTCDataChannelHandler(
-      label, init, interfaces_->GetDelegate());
+  return new MockWebRTCDataChannelHandler(label, init,
+                                          interfaces_->GetDelegate());
 }
 
 WebRTCDTMFSenderHandler* MockWebRTCPeerConnectionHandler::createDTMFSender(
     const WebMediaStreamTrack& track) {
   return new MockWebRTCDTMFSenderHandler(track, interfaces_->GetDelegate());
 }
 
 void MockWebRTCPeerConnectionHandler::stop() {
   stopped_ = true;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace test_runner