Remove MediaSource renderer from the remoting client plugin

remoting/client/plugin/media_source_video_renderer.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 "remoting/client/plugin/media_source_video_renderer.h"
-
-#include <string.h>
-
-#include "base/callback_helpers.h"
-#include "base/logging.h"
-#include "base/time/time.h"
-#include "remoting/proto/video.pb.h"
-#include "remoting/protocol/session_config.h"
-#include "third_party/libwebm/source/mkvmuxer.hpp"
-
-namespace remoting {
-
-static int kFrameIntervalNs = 1000000;
-
-class MediaSourceVideoRenderer::VideoWriter : public mkvmuxer::IMkvWriter {
- public:
-  typedef std::vector<uint8_t> DataBuffer;
-
-  VideoWriter(const webrtc::DesktopSize& frame_size, const char* codec_id);
-  ~VideoWriter() override;
-
-  const webrtc::DesktopSize& size() { return frame_size_; }
-  int64_t last_frame_timestamp() { return timecode_ - kFrameIntervalNs; }
-
-  // IMkvWriter interface.
-  mkvmuxer::int32 Write(const void* buf, mkvmuxer::uint32 len) override;
-  mkvmuxer::int64 Position() const override;
-  mkvmuxer::int32 Position(mkvmuxer::int64 position) override;
-  bool Seekable() const override;
-  void ElementStartNotify(mkvmuxer::uint64 element_id,
-                          mkvmuxer::int64 position) override;
-
-  scoped_ptr<DataBuffer> OnVideoFrame(const std::string& video_data,
-                                      bool keyframe);
-
- private:
-  webrtc::DesktopSize frame_size_;
-  const char* codec_id_;
-
-  scoped_ptr<DataBuffer> output_data_;
-  int64_t position_;
-  scoped_ptr<mkvmuxer::Segment> segment_;
-  int64_t timecode_;
-};
-
-MediaSourceVideoRenderer::VideoWriter::VideoWriter(
-    const webrtc::DesktopSize& frame_size,
-    const char* codec_id)
-    : frame_size_(frame_size),
-      codec_id_(codec_id),
-      position_(0),
-      timecode_(0) {
-  segment_.reset(new mkvmuxer::Segment());
-  segment_->Init(this);
-  segment_->set_mode(mkvmuxer::Segment::kLive);
-
-  // DateUTC is specified in nanoseconds from 0:00 on January 1st, 2001.
-  base::Time::Exploded millennium_exploded;
-  memset(&millennium_exploded, 0, sizeof(millennium_exploded));
-  millennium_exploded.year = 2001;
-  millennium_exploded.month = 1;
-  millennium_exploded.day_of_month = 1;
-  segment_->GetSegmentInfo()->set_date_utc(
-      (base::Time::Now() - base::Time::FromUTCExploded(millennium_exploded))
-          .InMicroseconds() *
-      base::Time::kNanosecondsPerMicrosecond);
-
-  uint64 crop_right = 0;
-  int width = frame_size_.width();
-  if (width % 2 == 1) {
-    ++width;
-    crop_right = 1;
-  }
-
-  uint64 crop_bottom = 0;
-  int height = frame_size_.height();
-  if (height % 2 == 1) {
-    ++height;
-    crop_bottom = 1;
-  }
-
-  segment_->AddVideoTrack(width, height, 1);
-  mkvmuxer::VideoTrack* video_track =
-      reinterpret_cast<mkvmuxer::VideoTrack*>(segment_->GetTrackByNumber(1));
-  video_track->set_codec_id(codec_id_);
-  video_track->set_crop_right(crop_right);
-  video_track->set_crop_bottom(crop_bottom);
-  video_track->set_frame_rate(base::Time::kNanosecondsPerSecond /
-                              kFrameIntervalNs);
-  video_track->set_default_duration(kFrameIntervalNs);
-  mkvmuxer::SegmentInfo* const info = segment_->GetSegmentInfo();
-  info->set_writing_app("ChromotingViewer");
-  info->set_muxing_app("ChromotingViewer");
-}
-
-MediaSourceVideoRenderer::VideoWriter::~VideoWriter() {}
-
-mkvmuxer::int32 MediaSourceVideoRenderer::VideoWriter::Write(
-    const void* buf,
-    mkvmuxer::uint32 len) {
-  output_data_->insert(output_data_->end(),
-                       reinterpret_cast<const char*>(buf),
-                       reinterpret_cast<const char*>(buf) + len);
-  position_ += len;
-  return 0;
-}
-
-mkvmuxer::int64 MediaSourceVideoRenderer::VideoWriter::Position() const {
-  return position_;
-}
-
-mkvmuxer::int32 MediaSourceVideoRenderer::VideoWriter::Position(
-    mkvmuxer::int64 position) {
-  return -1;
-}
-
-bool MediaSourceVideoRenderer::VideoWriter::Seekable() const {
-  return false;
-}
-
-void MediaSourceVideoRenderer::VideoWriter::ElementStartNotify(
-    mkvmuxer::uint64 element_id,
-    mkvmuxer::int64 position) {
-}
-
-scoped_ptr<MediaSourceVideoRenderer::VideoWriter::DataBuffer>
-MediaSourceVideoRenderer::VideoWriter::OnVideoFrame(
-    const std::string& video_data,
-    bool keyframe) {
-  DCHECK(!output_data_);
-
-  output_data_.reset(new DataBuffer());
-  segment_->AddFrame(reinterpret_cast<const uint8_t*>(video_data.data()),
-                     video_data.size(), 1, timecode_, keyframe);
-  timecode_ += kFrameIntervalNs;
-  return output_data_.Pass();
-}
-
-MediaSourceVideoRenderer::MediaSourceVideoRenderer(Delegate* delegate)
-    : delegate_(delegate),
-      codec_id_(mkvmuxer::Tracks::kVp8CodecId),
-      latest_sequence_number_(0) {
-}
-
-MediaSourceVideoRenderer::~MediaSourceVideoRenderer() {}
-
-void MediaSourceVideoRenderer::Initialize(
-    const protocol::SessionConfig& config) {
-  switch (config.video_config().codec) {
-    case protocol::ChannelConfig::CODEC_VP8:
-      format_string_ = "video/webm; codecs=\"vp8\"";
-      codec_id_ = mkvmuxer::Tracks::kVp8CodecId;
-      break;
-    case protocol::ChannelConfig::CODEC_VP9:
-      format_string_ = "video/webm; codecs=\"vp9\"";
-      codec_id_ = mkvmuxer::Tracks::kVp9CodecId;
-      break;
-    default:
-      NOTREACHED();
-  }
-}
-
-ChromotingStats* MediaSourceVideoRenderer::GetStats() {
-  return &stats_;
-}
-
-void MediaSourceVideoRenderer::ProcessVideoPacket(
-    scoped_ptr<VideoPacket> packet,
-    const base::Closure& done) {
-  base::ScopedClosureRunner done_runner(done);
-
-  // Don't need to do anything if the packet is empty. Host sends empty video
-  // packets when the screen is not changing.
-  if (!packet->data().size())
-    return;
-
-  // Update statistics.
-  stats_.video_frame_rate()->Record(1);
-  stats_.video_bandwidth()->Record(packet->data().size());
-  if (packet->has_capture_time_ms())
-    stats_.video_capture_ms()->Record(packet->capture_time_ms());
-  if (packet->has_encode_time_ms())
-    stats_.video_encode_ms()->Record(packet->encode_time_ms());
-  if (packet->has_client_sequence_number() &&
-      packet->client_sequence_number() > latest_sequence_number_) {
-    latest_sequence_number_ = packet->client_sequence_number();
-    base::TimeDelta round_trip_latency =
-        base::Time::Now() -
-        base::Time::FromInternalValue(packet->client_sequence_number());
-    stats_.round_trip_ms()->Record(round_trip_latency.InMilliseconds());
-  }
-
-  bool media_source_needs_reset = false;
-
-  webrtc::DesktopSize frame_size(packet->format().screen_width(),
-                                 packet->format().screen_height());
-  if (!writer_ ||
-      (!writer_->size().equals(frame_size) && !frame_size.is_empty())) {
-    media_source_needs_reset = true;
-    writer_.reset(new VideoWriter(frame_size, codec_id_));
-    delegate_->OnMediaSourceReset(format_string_);
-  }
-
-  webrtc::DesktopVector frame_dpi(packet->format().x_dpi(),
-                                  packet->format().y_dpi());
-  if (media_source_needs_reset || !frame_dpi_.equals(frame_dpi)) {
-    frame_dpi_ = frame_dpi;
-    delegate_->OnMediaSourceSize(frame_size, frame_dpi);
-  }
-
-  // Update the desktop shape region.
-  webrtc::DesktopRegion desktop_shape;
-  if (packet->has_use_desktop_shape()) {
-    for (int i = 0; i < packet->desktop_shape_rects_size(); ++i) {
-      Rect remoting_rect = packet->desktop_shape_rects(i);
-      desktop_shape.AddRect(webrtc::DesktopRect::MakeXYWH(
-          remoting_rect.x(), remoting_rect.y(),
-          remoting_rect.width(), remoting_rect.height()));
-    }
-  } else {
-    // Fallback for the case when the host didn't include the desktop shape.
-    desktop_shape =
-        webrtc::DesktopRegion(webrtc::DesktopRect::MakeSize(frame_size));
-  }
-
-  if (!desktop_shape_.Equals(desktop_shape)) {
-    desktop_shape_.Swap(&desktop_shape);
-    delegate_->OnMediaSourceShape(desktop_shape_);
-  }
-
-  // First bit is set to 0 for key frames.
-  bool keyframe = (packet->data()[0] & 1) == 0;
-
-  scoped_ptr<VideoWriter::DataBuffer> buffer =
-      writer_->OnVideoFrame(packet->data(), keyframe);
-  delegate_->OnMediaSourceData(&(*(buffer->begin())), buffer->size(), keyframe);
-}
-
-}  // namespace remoting