Adding a unit test to verify the IPC channel between the network and desktop processes.

media/video/capture/screen/screen_capturer_fake.cc

 // Copyright (c) 2012 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 "media/video/capture/screen/screen_capturer_fake.h"
 
 #include "base/time.h"
 #include "media/video/capture/screen/screen_capture_data.h"
 
 namespace media {
@@ skipping 21 matching lines @@
       box_speed_y_(kSpeed),
       current_buffer_(0) {
   ScreenConfigurationChanged();
 }
 
 ScreenCapturerFake::~ScreenCapturerFake() {
 }
 
 void ScreenCapturerFake::Start(Delegate* delegate) {
   delegate_ = delegate;
+
+  // Create memory for the buffers.
+  int buffer_size = size_.height() * bytes_per_row_;

[Cris Neckar, 2013/02/06 19:31:24]

nit: size_t

[alexeypa (please no reviews), 2013/02/06 22:58:39]

width, height and bytes_per_row_ are all |int| here. buffer_size is passed to
CreateSharedBuffer() which also expects it to be int. I guess it is better to
keep it as |int| in spite of the fact that it represents a memory buffer size.

+  for (int i = 0; i < kNumBuffers; i++) {
+    shared_buffers_[i] = delegate_->CreateSharedBuffer(buffer_size);
+    if (shared_buffers_[i]) {
+      buffers_[i] = reinterpret_cast<uint8*>(shared_buffers_[i]->ptr());
+    } else {
+      private_buffers_[i].reset(new uint8[buffer_size]);
+      buffers_[i] = private_buffers_[i].get();
+    }
+  }
 }
 
 void ScreenCapturerFake::Stop() {
 }
 
 void ScreenCapturerFake::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
 void ScreenCapturerFake::CaptureFrame() {
   base::Time capture_start_time = base::Time::Now();
 
   GenerateImage();
   helper_.InvalidateScreen(size_);
 
   SkRegion invalid_region;
   helper_.SwapInvalidRegion(&invalid_region);
 
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
 
   scoped_refptr<ScreenCaptureData> capture_data(new ScreenCaptureData(
-      buffers_[current_buffer_].get(), bytes_per_row_, size_));
+      buffers_[current_buffer_], bytes_per_row_, size_));
   capture_data->mutable_dirty_region() = invalid_region;
 
-  helper_.set_size_most_recent(capture_data->size());
+  helper_.set_size_most_recent(size_);
+
+  capture_data->set_shared_buffer(shared_buffers_[current_buffer_]);
 
   capture_data->set_capture_time_ms(
       (base::Time::Now() - capture_start_time).InMillisecondsRoundedUp());
   delegate_->OnCaptureCompleted(capture_data);
 }
 
 void ScreenCapturerFake::GenerateImage() {
-  memset(buffers_[current_buffer_].get(), 0xff,
+  memset(buffers_[current_buffer_], 0xff,
          size_.width() * size_.height() * ScreenCaptureData::kBytesPerPixel);
 
-  uint8* row = buffers_[current_buffer_].get() +
+  uint8* row = buffers_[current_buffer_] +
       (box_pos_y_ * size_.width() + box_pos_x_) *
       ScreenCaptureData::kBytesPerPixel;
 
   box_pos_x_ += box_speed_x_;
   if (box_pos_x_ + kBoxWidth >= size_.width() || box_pos_x_ == 0)
     box_speed_x_ = -box_speed_x_;
 
   box_pos_y_ += box_speed_y_;
   if (box_pos_y_ + kBoxHeight >= size_.height() || box_pos_y_ == 0)
     box_speed_y_ = -box_speed_y_;
@@ skipping 12 matching lines @@
       row[x * ScreenCaptureData::kBytesPerPixel + 2] = b;
       row[x * ScreenCaptureData::kBytesPerPixel + 3] = 0xff;
     }
     row += bytes_per_row_;
   }
 }
 
 void ScreenCapturerFake::ScreenConfigurationChanged() {
   size_ = SkISize::Make(kWidth, kHeight);
   bytes_per_row_ = size_.width() * ScreenCaptureData::kBytesPerPixel;
-
-  // Create memory for the buffers.
-  int buffer_size = size_.height() * bytes_per_row_;
-  for (int i = 0; i < kNumBuffers; i++) {
-    buffers_[i].reset(new uint8[buffer_size]);
-  }
 }
 
 }  // namespace media