Switch event type when a capture device has been stopped from the render process. This make sure th…

content/browser/renderer_host/media/video_capture_controller_unittest.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.
 
 // Unit test for VideoCaptureController.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
@@ skipping 43 matching lines @@
       : controller_(controller),
         message_loop_(message_loop),
         controller_id_(kDeviceId),
         process_handle_(base::kNullProcessHandle) {
   }
   virtual ~MockVideoCaptureControllerEventHandler() {}
 
   MOCK_METHOD1(DoBufferCreated, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoBufferReady, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoFrameInfo, void(const VideoCaptureControllerID&));
-  MOCK_METHOD1(DoPaused, void(const VideoCaptureControllerID&));
+  MOCK_METHOD1(DoEnded, void(const VideoCaptureControllerID&));
 
   virtual void OnError(const VideoCaptureControllerID& id) OVERRIDE {}
   virtual void OnBufferCreated(const VideoCaptureControllerID& id,
                                base::SharedMemoryHandle handle,
                                int length, int buffer_id) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
     DoBufferCreated(id);
   }
   virtual void OnBufferReady(const VideoCaptureControllerID& id,
                              int buffer_id,
                              base::Time timestamp) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
     DoBufferReady(id);
     message_loop_->PostTask(FROM_HERE,
         base::Bind(&VideoCaptureController::ReturnBuffer,
                    controller_, controller_id_, this, buffer_id));
   }
   virtual void OnFrameInfo(const VideoCaptureControllerID& id,
                            int width,
                            int height,
                            int frame_per_second) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
     DoFrameInfo(id);
   }
-  virtual void OnPaused(const VideoCaptureControllerID& id) OVERRIDE {
+  virtual void OnEnded(const VideoCaptureControllerID& id) OVERRIDE {
     EXPECT_EQ(id, controller_id_);
-    DoPaused(id);
+    DoEnded(id);
   }
 
   scoped_refptr<VideoCaptureController> controller_;
   MessageLoop* message_loop_;
   VideoCaptureControllerID controller_id_;
   base::ProcessHandle process_handle_;
 };
 
 class MockVideoCaptureManager : public VideoCaptureManager {
  public:
@@ skipping 131 matching lines @@
   EXPECT_CALL(*controller_handler_,
               DoBufferCreated(controller_handler_->controller_id_))
       .Times(AtLeast(1));
   EXPECT_CALL(*controller_handler_,
               DoBufferReady(controller_handler_->controller_id_))
       .Times(AtLeast(1))
       .WillOnce(StopSession(controller_.get(),
                             vcm_->video_session_id_,
                             message_loop_.get()));
   EXPECT_CALL(*controller_handler_,
-              DoPaused(controller_handler_->controller_id_))
+              DoEnded(controller_handler_->controller_id_))
       .Times(1);
 
   controller_->StartCapture(controller_handler_->controller_id_,
                             controller_handler_.get(),
                             controller_handler_->process_handle_,
                             capture_params);
   message_loop_->Run();
 
   // The session is stopped now. There should be no buffer coming from
   // controller.
   EXPECT_CALL(*controller_handler_,
               DoBufferReady(controller_handler_->controller_id_))
       .Times(0);
   message_loop_->PostDelayedTask(
       FROM_HERE, MessageLoop::QuitClosure(), base::TimeDelta::FromSeconds(1));
   message_loop_->Run();
 
   EXPECT_CALL(*vcm_,
               StopCapture(vcm_->video_session_id_))
       .Times(1);
   controller_->StopCapture(controller_handler_->controller_id_,
                            controller_handler_.get());
 }
 
 }  // namespace content