Don't use WebLockOrientationCallback::OnSuccess() with arguments.

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 14 matching lines @@
 // any time.
 class MockLockOrientationCallback :
     public blink::WebLockOrientationCallback {
  public:
   struct LockOrientationResultHolder {
     LockOrientationResultHolder()
         : succeeded_(false), failed_(false) {}
 
     bool succeeded_;
     bool failed_;
-    unsigned angle_;
-    blink::WebScreenOrientationType orientation_;
     blink::WebLockOrientationError error_;
   };
 
   explicit MockLockOrientationCallback(LockOrientationResultHolder* results)
       : results_(results) {}
 
-  virtual void onSuccess(unsigned angle,
-                         blink::WebScreenOrientationType orientation) {
+  virtual void onSuccess() {
     results_->succeeded_ = true;
-    results_->angle_ = angle;
-    results_->orientation_ = orientation;
   }
 
   virtual void onError(blink::WebLockOrientationError error) {
     results_->failed_ = true;
     results_->error_ = error;
   }
 
  private:
   virtual ~MockLockOrientationCallback() {}
 
@@ skipping 105 matching lines @@
 
     EXPECT_FALSE(callback_results.succeeded_);
     EXPECT_TRUE(callback_results.failed_);
     EXPECT_EQ(*it, callback_results.error_);
 
     sink().ClearMessages();
   }
 }
 
 // Test that when a LockSuccess message is received, the request is set as
-// succeeded with the correct values.
+// succeeded.
 TEST_F(ScreenOrientationDispatcherTest, LockRequest_Success) {
-  struct ScreenOrientationInformation {
-    unsigned angle;
-    blink::WebScreenOrientationType type;
-  } orientations[] = {
-    { 0, blink::WebScreenOrientationPortraitPrimary },
-    { 0, blink::WebScreenOrientationLandscapePrimary },
-    { 90, blink::WebScreenOrientationPortraitSecondary },
-    { 90, blink::WebScreenOrientationLandscapePrimary }
-  };
+  MockLockOrientationCallback::LockOrientationResultHolder callback_results;
+  LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
+                  new MockLockOrientationCallback(&callback_results));
 
-  int orientationsCount = 4;
+  int request_id = GetFirstLockRequestIdFromSink();
+  OnMessageReceived(ScreenOrientationMsg_LockSuccess(routing_id(),
+                                                     request_id));
 
-  for (int i = 0; i < orientationsCount; ++i) {
-    MockLockOrientationCallback::LockOrientationResultHolder callback_results;
-    LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
-                    new MockLockOrientationCallback(&callback_results));
+  EXPECT_TRUE(callback_results.succeeded_);
+  EXPECT_FALSE(callback_results.failed_);
 
-    int request_id = GetFirstLockRequestIdFromSink();
-    OnMessageReceived(ScreenOrientationMsg_LockSuccess(routing_id(),
-                                                       request_id,
-                                                       orientations[i].angle,
-                                                       orientations[i].type));
-
-    EXPECT_TRUE(callback_results.succeeded_);
-    EXPECT_FALSE(callback_results.failed_);
-    EXPECT_EQ(orientations[i].angle, callback_results.angle_);
-    EXPECT_EQ(orientations[i].type, callback_results.orientation_);
-
-    sink().ClearMessages();
-  }
+  sink().ClearMessages();
 }
 
 // Test an edge case: a LockSuccess is received but it matches no pending
 // callback.
 TEST_F(ScreenOrientationDispatcherTest, SuccessForUnknownRequest) {
   MockLockOrientationCallback::LockOrientationResultHolder callback_results;
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results));
 
   int request_id = GetFirstLockRequestIdFromSink();
-  OnMessageReceived(ScreenOrientationMsg_LockSuccess(
-      routing_id(),
-      request_id + 1,
-      90,
-      blink::WebScreenOrientationLandscapePrimary));
+  OnMessageReceived(ScreenOrientationMsg_LockSuccess(routing_id(),
+                                                     request_id + 1));
 
   EXPECT_FALSE(callback_results.succeeded_);
   EXPECT_FALSE(callback_results.failed_);
 }
 
 // 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,
@@ skipping 19 matching lines @@
 
   LockOrientation(blink::WebScreenOrientationLockPortraitPrimary,
                   new MockLockOrientationCallback(&callback_results1));
   int request_id1 = GetFirstLockRequestIdFromSink();
 
   LockOrientation(blink::WebScreenOrientationLockLandscapePrimary,
                   new MockLockOrientationCallback(&callback_results2));
 
   // callback_results1 must be rejected, tested in CancelPending_DoubleLock.
 
-  OnMessageReceived(ScreenOrientationMsg_LockSuccess(
-      routing_id(),
-      request_id1,
-      0,
-      blink::WebScreenOrientationPortraitPrimary));
+  OnMessageReceived(ScreenOrientationMsg_LockSuccess(routing_id(),
+                                                     request_id1));
 
   // First request is still rejected.
   EXPECT_FALSE(callback_results1.succeeded_);
   EXPECT_TRUE(callback_results1.failed_);
   EXPECT_EQ(blink::WebLockOrientationErrorCanceled, callback_results1.error_);
 
   // Second request is still pending.
   EXPECT_FALSE(callback_results2.succeeded_);
   EXPECT_FALSE(callback_results2.failed_);
 }
 
 }  // namespace content