Use WebLockOrientationError instead of WebLockOrientationCallbackErrorType.

content/renderer/screen_orientation/screen_orientation_dispatcher_unittest.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 "screen_orientation_dispatcher.h"
 
 #include <list>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 16 matching lines @@
     public blink::WebLockOrientationCallback {
  public:
   struct LockOrientationResultHolder {
     LockOrientationResultHolder()
         : succeeded_(false), failed_(false) {}
 
     bool succeeded_;
     bool failed_;
     unsigned angle_;
     blink::WebScreenOrientationType orientation_;
-    blink::WebLockOrientationCallback::ErrorType error_;
+    blink::WebLockOrientationError error_;
   };
 
   explicit MockLockOrientationCallback(LockOrientationResultHolder* results)
       : results_(results) {}
 
   virtual void onSuccess(unsigned angle,
                          blink::WebScreenOrientationType orientation) {
     results_->succeeded_ = true;
     results_->angle_ = angle;
     results_->orientation_ = orientation;
   }
 
-  virtual void onError(
-      blink::WebLockOrientationCallback::ErrorType error) {
+  virtual void onError(blink::WebLockOrientationError error) {
     results_->failed_ = true;
     results_->error_ = error;
   }
 
  private:
   virtual ~MockLockOrientationCallback() {}
 
   LockOrientationResultHolder* results_;
 };
 
@@ skipping 55 matching lines @@
 // Test that calling lockOrientation() followed by unlockOrientation() cancel
 // the lockOrientation().
 TEST_F(ScreenOrientationDispatcherTest, CancelPending_Unlocking) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
   UnlockOrientation();
 
   EXPECT_FALSE(callback_results.succeeded_);
   EXPECT_TRUE(callback_results.failed_);
-  EXPECT_EQ(blink::WebLockOrientationCallback::ErrorTypeCanceled,
-            callback_results.error_);
+  EXPECT_EQ(blink::WebLockOrientationErrorCanceled, callback_results.error_);
 }
 
 // Test that calling lockOrientation() twice cancel the first lockOrientation().
 TEST_F(ScreenOrientationDispatcherTest, CancelPending_DoubleLock) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   // We create the object to prevent leaks but never actually use it.
   MockLockOrientationCallback::LockOrientationResultHolder callback_results2;
 
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results2));
 
   EXPECT_FALSE(callback_results.succeeded_);
   EXPECT_TRUE(callback_results.failed_);
-  EXPECT_EQ(blink::WebLockOrientationCallback::ErrorTypeCanceled,
-            callback_results.error_);
+  EXPECT_EQ(blink::WebLockOrientationErrorCanceled, callback_results.error_);
 }
 
 // Test that when a LockError message is received, the request is set as failed
 // with the correct values.
 TEST_F(ScreenOrientationDispatcherTest, LockRequest_Error) {
-  std::list<blink::WebLockOrientationCallback::ErrorType> errors;
-  errors.push_back(blink::WebLockOrientationCallback::ErrorTypeNotAvailable);
+  std::list<blink::WebLockOrientationError> errors;
+  errors.push_back(blink::WebLockOrientationErrorNotAvailable);
   errors.push_back(
-      blink::WebLockOrientationCallback::ErrorTypeFullScreenRequired);
-  errors.push_back(blink::WebLockOrientationCallback::ErrorTypeCanceled);
+      blink::WebLockOrientationErrorFullScreenRequired);
+  errors.push_back(blink::WebLockOrientationErrorCanceled);
 
-  for (std::list<blink::WebLockOrientationCallback::ErrorType>::const_iterator
+  for (std::list<blink::WebLockOrientationError>::const_iterator
           it = errors.begin(); it != errors.end(); ++it) {
     MockLockOrientationCallback::LockOrientationResultHolder callback_results;
     LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                     new MockLockOrientationCallback(&callback_results));
 
     int request_id = GetFirstLockRequestIdFromSink();
     OnMessageReceived(
         ScreenOrientationMsg_LockError(routing_id(), request_id, *it));
 
     EXPECT_FALSE(callback_results.succeeded_);
@@ skipping 59 matching lines @@
 
 // Test an edge case: a LockError is received but it matches no pending
 // callback.
 TEST_F(ScreenOrientationDispatcherTest, ErrorForUnknownRequest) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
 
   int request_id = GetFirstLockRequestIdFromSink();
   OnMessageReceived(ScreenOrientationMsg_LockError(
-      routing_id(),
-      request_id + 1,
-      blink::WebLockOrientationCallback::ErrorTypeCanceled));
+      routing_id(), request_id + 1, blink::WebLockOrientationErrorCanceled));
 
   EXPECT_FALSE(callback_results.succeeded_);
   EXPECT_FALSE(callback_results.failed_);
 }
 
 // Test the following scenario:
 // - request1 is received by the dispatcher;
 // - request2 is received by the dispatcher;
 // - request1 is rejected;
 // - request1 success response is received.
@@ skipping 13 matching lines @@
 
   OnMessageReceived(ScreenOrientationMsg_LockSuccess(
       routing_id(),
       request_id1,
       0,
       blink::WebScreenOrientationPortraitPrimary));
 
   // First request is still rejected.
   EXPECT_FALSE(callback_results1.succeeded_);
   EXPECT_TRUE(callback_results1.failed_);
-  EXPECT_EQ(blink::WebLockOrientationCallback::ErrorTypeCanceled,
-            callback_results1.error_);
+  EXPECT_EQ(blink::WebLockOrientationErrorCanceled, callback_results1.error_);
 
   // Second request is still pending.
   EXPECT_FALSE(callback_results2.succeeded_);
   EXPECT_FALSE(callback_results2.failed_);
 }
 
 }  // namespace content