Supress pipeline errors during destruction and suspend.

media/base/pipeline_impl_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.
 
 #include "media/base/pipeline_impl.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
@@ skipping 849 matching lines @@
         break;
 
       case kFlushing:
       case kSeeking:
         DoInitialize(state, stop_or_error);
         DoSeek(state, stop_or_error);
         break;
 
       case kPlaying:
         DoInitialize(state, stop_or_error);
-        DoStopOrError(stop_or_error);
+        DoStopOrError(stop_or_error, true);
         break;
 
       case kSuspending:
       case kSuspended:
       case kResuming:
         DoInitialize(state, stop_or_error);
         DoSuspend(state, stop_or_error);
         break;
     }
   }
@@ skipping 142 matching lines @@
       return status;
     }
 
     NOTREACHED() << "State not supported: " << state;
     return status;
   }
 
   void DoSuspend(TeardownState state, StopOrError stop_or_error) {
     PipelineStatus status = SetSuspendExpectations(state, stop_or_error);
 
-    if (state != kSuspended) {
-      // DoStopOrError() handles these for kSuspended.
+    if (state == kResuming) {
       EXPECT_CALL(*demuxer_, Stop());
-      if (status == PIPELINE_OK) {
+      if (status == PIPELINE_OK)
         ExpectPipelineStopAndDestroyPipeline();
-      }
     }
 
     PipelineImplTest::DoSuspend();
 
-    if (state == kSuspended) {
-      DoStopOrError(stop_or_error);
-    } else if (state == kResuming) {
+    if (state == kResuming) {
       PipelineImplTest::DoResume(base::TimeDelta());
+      return;
     }
+
+    // kSuspended, kSuspending never throw errors, since Resume() is always able
+    // to restore the pipeline to a pristine state.
+    DoStopOrError(stop_or_error, false);
   }
 
   PipelineStatus SetSuspendExpectations(TeardownState state,
                                         StopOrError stop_or_error) {
     PipelineStatus status = PIPELINE_OK;
     base::Closure stop_cb =
         base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     EXPECT_CALL(*renderer_, SetPlaybackRate(0));
-    if (state == kSuspended || state == kResuming) {
-      EXPECT_CALL(*renderer_, Flush(_))
-          .WillOnce(DoAll(
-              SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-              RunClosure<0>()));
-      EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
-      EXPECT_CALL(callbacks_, OnSuspend(PIPELINE_OK));
-      if (state == kResuming) {
-        if (stop_or_error == kStop) {
-          EXPECT_CALL(*demuxer_, Seek(_, _))
-              .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
-                              RunCallback<1>(PIPELINE_OK)));
-          EXPECT_CALL(callbacks_, OnResume(PIPELINE_OK));
-        } else {
-          status = PIPELINE_ERROR_READ;
-          EXPECT_CALL(*demuxer_, Seek(_, _)).WillOnce(RunCallback<1>(status));
-          EXPECT_CALL(callbacks_, OnResume(status));
-        }
-      }
-      return status;
-    } else if (state == kSuspending) {
+    EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
+    EXPECT_CALL(callbacks_, OnSuspend(PIPELINE_OK));
+    EXPECT_CALL(*renderer_, Flush(_))
+        .WillOnce(DoAll(
+            SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
+            RunClosure<0>()));
+    if (state == kResuming) {
       if (stop_or_error == kStop) {
-        EXPECT_CALL(*renderer_, Flush(_))
-            .WillOnce(DoAll(
-                Stop(pipeline_.get(), stop_cb),
-                SetBufferingState(&buffering_state_cb_, BUFFERING_HAVE_NOTHING),
-                RunClosure<0>()));
-        EXPECT_CALL(callbacks_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
-        EXPECT_CALL(callbacks_, OnSuspend(PIPELINE_OK));
+        EXPECT_CALL(*demuxer_, Seek(_, _))
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
+                            RunCallback<1>(PIPELINE_OK)));
+        EXPECT_CALL(callbacks_, OnResume(PIPELINE_OK));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*renderer_, Flush(_))
-            .WillOnce(SetError(pipeline_.get(), status));
-        EXPECT_CALL(callbacks_, OnSuspend(status));
+        EXPECT_CALL(*demuxer_, Seek(_, _)).WillOnce(RunCallback<1>(status));
+        EXPECT_CALL(callbacks_, OnResume(status));
       }
-      return status;
+    } else if (state != kSuspended && state != kSuspending) {
+      NOTREACHED() << "State not supported: " << state;
     }
 
-    NOTREACHED() << "State not supported: " << state;
     return status;
   }
 
-  void DoStopOrError(StopOrError stop_or_error) {
+  void DoStopOrError(StopOrError stop_or_error, bool expect_errors) {
     InSequence s;
 
-    EXPECT_CALL(*demuxer_, Stop());
-
     switch (stop_or_error) {
       case kStop:
+        EXPECT_CALL(*demuxer_, Stop());
         ExpectPipelineStopAndDestroyPipeline();
         pipeline_->Stop(
             base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
         break;
 
       case kError:
-        EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
+        if (expect_errors) {
+          EXPECT_CALL(*demuxer_, Stop());
+          EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
+        }
         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
         break;
 
       case kErrorAndStop:
-        EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
+        EXPECT_CALL(*demuxer_, Stop());
+        if (expect_errors)
+          EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
         ExpectPipelineStopAndDestroyPipeline();
         pipeline_->SetErrorForTesting(PIPELINE_ERROR_READ);
         message_loop_.RunUntilIdle();
         pipeline_->Stop(
             base::Bind(&CallbackHelper::OnStop, base::Unretained(&callbacks_)));
         break;
     }
 
     message_loop_.RunUntilIdle();
   }
@@ skipping 21 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspending);
 INSTANTIATE_TEARDOWN_TEST(Error, Suspended);
 INSTANTIATE_TEARDOWN_TEST(Error, Resuming);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Suspended);
 
 }  // namespace media