Add video frame recording capability to Chromoting hosts.

remoting/host/video_frame_recorder.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/host/video_frame_recorder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ skipping 89 matching lines @@
 };
 
 VideoFrameRecorder::VideoFrameRecorder()
     : content_bytes_(0),
       max_content_bytes_(0),
       enable_recording_(false),
       weak_factory_(this) {
 }
 
 VideoFrameRecorder::~VideoFrameRecorder() {
-  SetEnableRecording(false);
-  STLDeleteElements(&recorded_frames_);
+  DetachVideoEncoderWrapper();
 }
 
 scoped_ptr<VideoEncoder> VideoFrameRecorder::WrapVideoEncoder(
     scoped_ptr<VideoEncoder> encoder) {
+  DCHECK(!encoder_task_runner_);
   DCHECK(!caller_task_runner_);
   caller_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   scoped_ptr<RecordingVideoEncoder> recording_encoder(
       new RecordingVideoEncoder(encoder.Pass(),
                                 caller_task_runner_,
                                 weak_factory_.GetWeakPtr()));
   recording_encoder_ = recording_encoder->AsWeakPtr();
 
   return recording_encoder.PassAs<VideoEncoder>();
 }
 
+void VideoFrameRecorder::DetachVideoEncoderWrapper() {
+  DCHECK(!caller_task_runner_ || caller_task_runner_->BelongsToCurrentThread());
+
+  // Immediately detach the wrapper from this recorder.
+  weak_factory_.InvalidateWeakPtrs();
+
+  // Clean up any pending recorded frames.
+  STLDeleteElements(&recorded_frames_);
+  content_bytes_ = 0;
+
+  // Tell the wrapper to stop recording and posting frames to us.
+  if (encoder_task_runner_) {
+    encoder_task_runner_->PostTask(FROM_HERE,
+        base::Bind(&RecordingVideoEncoder::SetEnableRecording,
+                   recording_encoder_, false));
+  }
+
+  // Detach this recorder from the calling and encode threads.
+  caller_task_runner_ = NULL;
+  encoder_task_runner_ = NULL;
+}
+
 void VideoFrameRecorder::SetEnableRecording(bool enable_recording) {
   DCHECK(!caller_task_runner_ || caller_task_runner_->BelongsToCurrentThread());
 
   if (enable_recording_ == enable_recording) {
     return;
   }
   enable_recording_ = enable_recording;
 
   if (encoder_task_runner_) {
     encoder_task_runner_->PostTask(FROM_HERE,
@@ skipping 60 matching lines @@
   if (content_bytes_ + frame_bytes > max_content_bytes_) {
     return;
   }
 
   // Store the frame and update the content byte count.
   recorded_frames_.push_back(frame.release());
   content_bytes_ += frame_bytes;
 }
 
 }  // namespace remoting