Fix Java Checkstyle issues.

content/public/android/javatests/src/org/chromium/content/browser/JavaBridgeBasicsTest.java

 // Copyright 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.
 
 package org.chromium.content.browser;
 
 import android.test.suitebuilder.annotation.SmallTest;
 
 import org.chromium.base.test.util.Feature;
 import org.chromium.content.browser.test.util.TestCallbackHelperContainer;
@@ skipping 207 matching lines @@
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testCallingInvalidMethodRaisesException() throws Throwable {
         assertRaisesException("testController.foo()");
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testUncaughtJavaExceptionRaisesJavaScriptException() throws Throwable {
         injectObjectAndReload(new Object() {
-            public void method() { throw new RuntimeException("foo"); }
+            public void method() {
+                throw new RuntimeException("foo");
+            }
         }, "testObject");
         assertRaisesException("testObject.method()");
     }
 
     // Note that this requires that we can pass a JavaScript string to Java.
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testTypeOfStaticMethod() throws Throwable {
         injectObjectAndReload(new ObjectWithStaticMethod(), "testObject");
         executeJavaScript("testController.setStringValue(typeof testObject.staticMethod)");
@@ skipping 19 matching lines @@
         assertEquals("undefined",
                 executeJavaScriptAndGetStringResult("typeof testObject.method"));
         assertEquals("undefined",
                 executeJavaScriptAndGetStringResult("typeof testObject.method2"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReplaceInjectedObject() throws Throwable {
         injectObjectAndReload(new Object() {
-            public void method() { mTestController.setStringValue("object 1"); }
+            public void method() {
+                mTestController.setStringValue("object 1");
+            }
         }, "testObject");
         executeJavaScript("testObject.method()");
         assertEquals("object 1", mTestController.waitForStringValue());
 
         injectObjectAndReload(new Object() {
-            public void method() { mTestController.setStringValue("object 2"); }
+            public void method() {
+                mTestController.setStringValue("object 2");
+            }
         }, "testObject");
         executeJavaScript("testObject.method()");
         assertEquals("object 2", mTestController.waitForStringValue());
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testInjectNullObjectIsIgnored() throws Throwable {
         injectObjectAndReload(null, "testObject");
         assertEquals("undefined", executeJavaScriptAndGetStringResult("typeof testObject"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReplaceInjectedObjectWithNullObjectIsIgnored() throws Throwable {
         injectObjectAndReload(new Object(), "testObject");
         assertEquals("object", executeJavaScriptAndGetStringResult("typeof testObject"));
         injectObjectAndReload(null, "testObject");
         assertEquals("object", executeJavaScriptAndGetStringResult("typeof testObject"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testCallOverloadedMethodWithDifferentNumberOfArguments() throws Throwable {
         injectObjectAndReload(new Object() {
-            public void method() { mTestController.setStringValue("0 args"); }
-            public void method(int x) { mTestController.setStringValue("1 arg"); }
-            public void method(int x, int y) { mTestController.setStringValue("2 args"); }
+            public void method() {
+                mTestController.setStringValue("0 args");
+            }
+
+            public void method(int x) {
+                mTestController.setStringValue("1 arg");
+            }
+
+            public void method(int x, int y) {
+                mTestController.setStringValue("2 args");
+            }
         }, "testObject");
         executeJavaScript("testObject.method()");
         assertEquals("0 args", mTestController.waitForStringValue());
         executeJavaScript("testObject.method(42)");
         assertEquals("1 arg", mTestController.waitForStringValue());
         executeJavaScript("testObject.method(null)");
         assertEquals("1 arg", mTestController.waitForStringValue());
         executeJavaScript("testObject.method(undefined)");
         assertEquals("1 arg", mTestController.waitForStringValue());
         executeJavaScript("testObject.method(42, 42)");
@@ skipping 24 matching lines @@
         synchronousPageReload();
         assertEquals("object", executeJavaScriptAndGetStringResult("typeof testController"));
         assertEquals("undefined", executeJavaScriptAndGetStringResult("testController.myProperty"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testSameObjectInjectedMultipleTimes() throws Throwable {
         class TestObject {
             private int mNumMethodInvocations;
-            public void method() { mTestController.setIntValue(++mNumMethodInvocations); }
+
+            public void method() {
+                mTestController.setIntValue(++mNumMethodInvocations);
+            }
         }
         final TestObject testObject = new TestObject();
         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
                 mTestCallbackHelperContainer.getOnPageFinishedHelper();
         int currentCallCount = onPageFinishedHelper.getCallCount();
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
                 getContentViewCore().addPossiblyUnsafeJavascriptInterface(
                         testObject, "testObject1", null);
                 getContentViewCore().addPossiblyUnsafeJavascriptInterface(
                         testObject, "testObject2", null);
                 getContentViewCore().getWebContents().getNavigationController().reload(true);
             }
         });
         onPageFinishedHelper.waitForCallback(currentCallCount);
         executeJavaScript("testObject1.method()");
         assertEquals(1, mTestController.waitForIntValue());
         executeJavaScript("testObject2.method()");
         assertEquals(2, mTestController.waitForIntValue());
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testCallMethodOnReturnedObject() throws Throwable {
         injectObjectAndReload(new Object() {
             public Object getInnerObject() {
                 return new Object() {
-                    public void method(int x) { mTestController.setIntValue(x); }
+                    public void method(int x) {
+                        mTestController.setIntValue(x);
+                    }
                 };
             }
         }, "testObject");
         executeJavaScript("testObject.getInnerObject().method(42)");
         assertEquals(42, mTestController.waitForIntValue());
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReturnedObjectInjectedElsewhere() throws Throwable {
         class InnerObject {
             private int mNumMethodInvocations;
-            public void method() { mTestController.setIntValue(++mNumMethodInvocations); }
+
+            public void method() {
+                mTestController.setIntValue(++mNumMethodInvocations);
+            }
         }
         final InnerObject innerObject = new InnerObject();
         final Object object = new Object() {
             public InnerObject getInnerObject() {
                 return innerObject;
             }
         };
         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
                 mTestCallbackHelperContainer.getOnPageFinishedHelper();
         int currentCallCount = onPageFinishedHelper.getCallCount();
@@ skipping 94 matching lines @@
             public void run() {
                 assertFalse(threadId == Thread.currentThread().getId());
             }
         });
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testPublicInheritedMethod() throws Throwable {
         class Base {
-            public void method(int x) { mTestController.setIntValue(x); }
+            public void method(int x) {
+                mTestController.setIntValue(x);
+            }
         }
         class Derived extends Base {
         }
         injectObjectAndReload(new Derived(), "testObject");
         assertEquals("function", executeJavaScriptAndGetStringResult("typeof testObject.method"));
         executeJavaScript("testObject.method(42)");
         assertEquals(42, mTestController.waitForIntValue());
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testPrivateInheritedMethod() throws Throwable {
         class Base {
             private void method() {}
         }
         class Derived extends Base {
         }
         injectObjectAndReload(new Derived(), "testObject");
         assertEquals("undefined", executeJavaScriptAndGetStringResult("typeof testObject.method"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testOverriddenMethod() throws Throwable {
         class Base {
-            public void method() { mTestController.setStringValue("base"); }
+            public void method() {
+                mTestController.setStringValue("base");
+            }
         }
         class Derived extends Base {
             @Override
-            public void method() { mTestController.setStringValue("derived"); }
+            public void method() {
+                mTestController.setStringValue("derived");
+            }
         }
         injectObjectAndReload(new Derived(), "testObject");
         executeJavaScript("testObject.method()");
         assertEquals("derived", mTestController.waitForStringValue());
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testEnumerateMembers() throws Throwable {
         injectObjectAndReload(new Object() {
             public void method() {}
             private void privateMethod() {}
             public int field;
             private int mPrivateField;
         }, "testObject");
         executeJavaScript(
                 "var result = \"\"; " +
                 "for (x in testObject) { result += \" \" + x } " +
                 "testController.setStringValue(result);");
         assertEquals(" equals getClass hashCode method notify notifyAll toString wait",
                 mTestController.waitForStringValue());
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReflectPublicMethod() throws Throwable {
         injectObjectAndReload(new Object() {
-            public Class<?> myGetClass() { return getClass(); }
-            public String method() { return "foo"; }
+            public Class<?> myGetClass() {
+                return getClass();
+            }
+
+            public String method() {
+                return "foo";
+            }
         }, "testObject");
         assertEquals("foo", executeJavaScriptAndGetStringResult(
                 "testObject.myGetClass().getMethod('method', null).invoke(testObject, null)" +
                 ".toString()"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReflectPublicField() throws Throwable {
         injectObjectAndReload(new Object() {
-            public Class<?> myGetClass() { return getClass(); }
+            public Class<?> myGetClass() {
+                return getClass();
+            }
+
             public String field = "foo";
         }, "testObject");
         assertEquals("foo", executeJavaScriptAndGetStringResult(
                 "testObject.myGetClass().getField('field').get(testObject).toString()"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReflectPrivateMethodRaisesException() throws Throwable {
         injectObjectAndReload(new Object() {
-            public Class<?> myGetClass() { return getClass(); }
+            public Class<?> myGetClass() {
+                return getClass();
+            }
+
             private void method() {};
         }, "testObject");
         assertRaisesException("testObject.myGetClass().getMethod('method', null)");
         // getDeclaredMethod() is able to access a private method, but invoke()
         // throws a Java exception.
         assertRaisesException(
                 "testObject.myGetClass().getDeclaredMethod('method', null)." +
                 "invoke(testObject, null)");
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testReflectPrivateFieldRaisesException() throws Throwable {
         injectObjectAndReload(new Object() {
-            public Class<?> myGetClass() { return getClass(); }
+            public Class<?> myGetClass() {
+                return getClass();
+            }
+
             private int mField;
         }, "testObject");
         assertRaisesException("testObject.myGetClass().getField('field')");
         // getDeclaredField() is able to access a private field, but getInt()
         // throws a Java exception.
         assertRaisesException(
                 "testObject.myGetClass().getDeclaredField('field').getInt(testObject)");
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testAllowNonAnnotatedMethods() throws Throwable {
         injectObjectAndReload(new Object() {
-            public String allowed() { return "foo"; }
+            public String allowed() {
+                return "foo";
+            }
         }, "testObject", null);
 
         // Test calling a method of an explicitly inherited class (Base#allowed()).
         assertEquals("foo", executeJavaScriptAndGetStringResult("testObject.allowed()"));
 
         // Test calling a method of an implicitly inherited class (Object#toString()).
         assertEquals("string", executeJavaScriptAndGetStringResult("typeof testObject.toString()"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testAllowOnlyAnnotatedMethods() throws Throwable {
         injectObjectAndReload(new Object() {
             @JavascriptInterface
-            public String allowed() { return "foo"; }
+            public String allowed() {
+                return "foo";
+            }
 
-            public String disallowed() { return "bar"; }
+            public String disallowed() {
+                return "bar";
+            }
         }, "testObject", JavascriptInterface.class);
 
         // getClass() is an Object method and does not have the @JavascriptInterface annotation and
         // should not be able to be called.
         assertRaisesException("testObject.getClass()");
         assertEquals("undefined", executeJavaScriptAndGetStringResult(
                 "typeof testObject.getClass"));
 
         // allowed() is marked with the @JavascriptInterface annotation and should be allowed to be
         // called.
         assertEquals("foo", executeJavaScriptAndGetStringResult("testObject.allowed()"));
 
         // disallowed() is not marked with the @JavascriptInterface annotation and should not be
         // able to be called.
         assertRaisesException("testObject.disallowed()");
         assertEquals("undefined", executeJavaScriptAndGetStringResult(
                 "typeof testObject.disallowed"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testAnnotationRequirementRetainsPropertyAcrossObjects() throws Throwable {
         class Test {
             @JavascriptInterface
-            public String safe() { return "foo"; }
+            public String safe() {
+                return "foo";
+            }
 
-            public String unsafe() { return "bar"; }
+            public String unsafe() {
+                return "bar";
+            }
         }
 
         class TestReturner {
             @JavascriptInterface
-            public Test getTest() { return new Test(); }
+            public Test getTest() {
+                return new Test();
+            }
         }
 
         // First test with safe mode off.
         injectObjectAndReload(new TestReturner(), "unsafeTestObject", null);
 
         // safe() should be able to be called regardless of whether or not we are in safe mode.
         assertEquals("foo", executeJavaScriptAndGetStringResult(
                 "unsafeTestObject.getTest().safe()"));
         // unsafe() should be able to be called because we are not in safe mode.
         assertEquals("bar", executeJavaScriptAndGetStringResult(
@@ skipping 42 matching lines @@
     @Retention(RetentionPolicy.RUNTIME)
     @Target({ElementType.METHOD})
     @interface TestAnnotation {
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testCustomAnnotationRestriction() throws Throwable {
         class Test {
             @TestAnnotation
-            public String checkTestAnnotationFoo() { return "bar"; }
+            public String checkTestAnnotationFoo() {
+                return "bar";
+            }
 
             @JavascriptInterface
-            public String checkJavascriptInterfaceFoo() { return "bar"; }
+            public String checkJavascriptInterfaceFoo() {
+                return "bar";
+            }
         }
 
         // Inject javascriptInterfaceObj and require the JavascriptInterface annotation.
         injectObjectAndReload(new Test(), "javascriptInterfaceObj", JavascriptInterface.class);
 
         // Test#testAnnotationFoo() should fail, as it isn't annotated with JavascriptInterface.
         assertRaisesException("javascriptInterfaceObj.checkTestAnnotationFoo()");
         assertEquals("undefined", executeJavaScriptAndGetStringResult(
                 "typeof javascriptInterfaceObj.checkTestAnnotationFoo"));
 
@@ skipping 11 matching lines @@
         // Test#javascriptInterfaceFoo() should fail, as it isn't annotated with TestAnnotation.
         assertRaisesException("testAnnotationObj.checkJavascriptInterfaceFoo()");
         assertEquals("undefined", executeJavaScriptAndGetStringResult(
                 "typeof testAnnotationObj.checkJavascriptInterfaceFoo"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testAddJavascriptInterfaceIsSafeByDefault() throws Throwable {
         class Test {
-            public String blocked() { return "bar"; }
+            public String blocked() {
+                return "bar";
+            }
 
             @JavascriptInterface
-            public String allowed() { return "bar"; }
+            public String allowed() {
+                return "bar";
+            }
         }
 
         // Manually inject the Test object, making sure to use the
         // ContentViewCore#addJavascriptInterface, not the possibly unsafe version.
         TestCallbackHelperContainer.OnPageFinishedHelper onPageFinishedHelper =
                 mTestCallbackHelperContainer.getOnPageFinishedHelper();
         int currentCallCount = onPageFinishedHelper.getCallCount();
         runTestOnUiThread(new Runnable() {
             @Override
             public void run() {
@@ skipping 12 matching lines @@
         assertRaisesException("testObject.blocked()");
         assertEquals("undefined", executeJavaScriptAndGetStringResult(
                 "typeof testObject.blocked"));
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testObjectsInspection() throws Throwable {
         class Test {
             @JavascriptInterface
-            public String m1() { return "foo"; }
+            public String m1() {
+                return "foo";
+            }
 
             @JavascriptInterface
-            public String m2() { return "bar"; }
+            public String m2() {
+                return "bar";
+            }
 
             @JavascriptInterface
-            public String m2(int x) { return "bar " + x; }
+            public String m2(int x) {
+                return "bar " + x;
+            }
         }
 
         final String jsObjectKeysTestTemplate = "Object.keys(%s).toString()";
         final String jsForInTestTemplate =
                 "(function(){" +
                 "  var s=[]; for(var m in %s) s.push(m); return s.join(\",\")" +
                 "})()";
         final String inspectableObjectName = "testObj1";
         final String nonInspectableObjectName = "testObj2";
 
@@ skipping 21 matching lines @@
     }
 
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testAccessToObjectGetClassIsBlocked() throws Throwable {
         injectObjectAndReload(new Object(), "testObject");
         assertEquals("function", executeJavaScriptAndGetStringResult("typeof testObject.getClass"));
         assertRaisesException("testObject.getClass()");
     }
 }