Fix style violations.

chrome/browser/renderer_host/chrome_render_widget_host_view_mac_delegate.mm

 // 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.
 
 #import "chrome/browser/renderer_host/chrome_render_widget_host_view_mac_delegate.h"
 
 #include <cmath>
 
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/debugger/devtools_window.h"
@@ skipping 90 matching lines @@
     [view_delegate_ spellCheckEnabled:enabled checked:checked];
   }
 
   ChromeRenderWidgetHostViewMacDelegate* view_delegate_;
 };
 
 }  // namespace ChromeRenderWidgetHostViewMacDelegateInternal
 
 @implementation ChromeRenderWidgetHostViewMacDelegate
 
-- (id)initWithRenderWidgetHost:(RenderWidgetHost*)render_widget_host {
+- (id)initWithRenderWidgetHost:(RenderWidgetHost*)renderWidgetHost {
   self = [super init];
   if (self) {
-    render_widget_host_ = render_widget_host;
-    NSView* native_view = render_widget_host_->view()->GetNativeView();
-    view_id_util::SetID(native_view, VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
+    renderWidgetHost_ = renderWidgetHost;
+    NSView* nativeView = renderWidgetHost_->view()->GetNativeView();
+    view_id_util::SetID(nativeView, VIEW_ID_TAB_CONTAINER_FOCUS_VIEW);
 
-    if (render_widget_host_->IsRenderView()) {
-      spelling_observer_.reset(
+    if (renderWidgetHost_->IsRenderView()) {
+      spellingObserver_.reset(
           new ChromeRenderWidgetHostViewMacDelegateInternal::
               SpellCheckRenderViewObserver(
-                  static_cast<RenderViewHost*>(render_widget_host_), self));
+                  static_cast<RenderViewHost*>(renderWidgetHost_), self));
     }
   }
   return self;
 }
 
 - (void)viewGone:(NSView*)view {
   view_id_util::UnsetID(view);
   [self autorelease];
 }
 
 - (BOOL)handleEvent:(NSEvent*)event {
   if ([event type] == NSScrollWheel)
     return [self maybeHandleHistorySwiping:event];
 
   return NO;
 }
 
 - (void)gotUnhandledWheelEvent {
   gotUnhandledWheelEvent_ = YES;
 }
 
 - (void)scrollOffsetPinnedToLeft:(BOOL)left toRight:(BOOL)right {
   isPinnedLeft_ = left;
   isPinnedRight_ = right;
 }
 
-- (void)setHasHorizontalScrollbar:(BOOL)has_horizontal_scrollbar {
-  hasHorizontalScrollbar_ = has_horizontal_scrollbar;
+- (void)setHasHorizontalScrollbar:(BOOL)hasHorizontalScrollbar {
+  hasHorizontalScrollbar_ = hasHorizontalScrollbar;
 }
 
 // Checks if |theEvent| should trigger history swiping, and if so, does
 // history swiping. Returns YES if the event was consumed or NO if it should
 // be passed on to the renderer.
 - (BOOL)maybeHandleHistorySwiping:(NSEvent*)theEvent {
   BOOL canUseLionApis = [theEvent respondsToSelector:@selector(phase)];
   if (!canUseLionApis)
     return NO;
 
   // Scroll events always go to the web first, and can only trigger history
   // swiping if they come back unhandled.
   if ([theEvent phase] == NSEventPhaseBegan) {
     totalScrollDelta_ = NSZeroSize;
     gotUnhandledWheelEvent_ = NO;
   }
 
-  if (!render_widget_host_ || !render_widget_host_->IsRenderView())
+  if (!renderWidgetHost_ || !renderWidgetHost_->IsRenderView())
     return NO;
   if (DevToolsWindow::IsDevToolsWindow(
-      static_cast<RenderViewHost*>(render_widget_host_))) {
+      static_cast<RenderViewHost*>(renderWidgetHost_))) {
     return NO;
   }
 
   BOOL suppressWheelEvent = NO;
   Browser* browser = BrowserList::FindBrowserWithWindow([theEvent window]);
   if (browser && [NSEvent isSwipeTrackingFromScrollEventsEnabled]) {
     content::WebContents* contents = browser->GetSelectedWebContents();
     if (contents && contents->GetURL() == GURL(chrome::kChromeUINewTabURL)) {
       // Always do history navigation on the NTP if it's enabled.
       gotUnhandledWheelEvent_ = YES;
@@ skipping 64 matching lines @@
       // in the wrong direction.
       [theEvent trackSwipeEventWithOptions:NSEventSwipeTrackingLockDirection
                   dampenAmountThresholdMin:-1
                                        max:1
                               usingHandler:^(CGFloat gestureAmount,
                                              NSEventPhase phase,
                                              BOOL isComplete,
                                              BOOL *stop) {
           if (phase == NSEventPhaseBegan) {
             [historyOverlay showPanelForView:
-                render_widget_host_->view()->GetNativeView()];
+                renderWidgetHost_->view()->GetNativeView()];
             return;
           }
 
           BOOL ended = phase == NSEventPhaseEnded;
 
           // Dismiss the panel before navigation for immediate visual feedback.
           [historyOverlay setProgress:gestureAmount];
           if (ended)
             [historyOverlay dismiss];
 
@@ skipping 18 matching lines @@
 }
 
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item
                       isValidItem:(BOOL*)valid {
   SEL action = [item action];
 
   // For now, this action is always enabled for render view;
   // this is sub-optimal.
   // TODO(suzhe): Plumb the "can*" methods up from WebCore.
   if (action == @selector(checkSpelling:)) {
-    *valid = render_widget_host_->IsRenderView();
+    *valid = renderWidgetHost_->IsRenderView();
     return YES;
   }
 
   if (action == @selector(toggleContinuousSpellChecking:)) {
     if ([(id)item respondsToSelector:@selector(setState:)]) {
-      NSCellStateValue checked_state =
-          spellcheck_checked_ ? NSOnState : NSOffState;
-      [(id)item setState:checked_state];
+      NSCellStateValue checkedState =
+          spellcheckChecked_ ? NSOnState : NSOffState;
+      [(id)item setState:checkedState];
     }
-    *valid = spellcheck_enabled_;
+    *valid = spellcheckEnabled_;
     return YES;
   }
 
   return NO;
 }
 
 // Spellchecking methods
 // The next five methods are implemented here since this class is the first
 // responder for anything in the browser.
 
 // This message is sent whenever the user specifies that a word should be
 // changed from the spellChecker.
 - (void)changeSpelling:(id)sender {
   // Grab the currently selected word from the spell panel, as this is the word
   // that we want to replace the selected word in the text with.
   NSString* newWord = [[sender selectedCell] stringValue];
   if (newWord != nil) {
-    render_widget_host_->Replace(base::SysNSStringToUTF16(newWord));
+    renderWidgetHost_->Replace(base::SysNSStringToUTF16(newWord));
   }
 }
 
 // This message is sent by NSSpellChecker whenever the next word should be
 // advanced to, either after a correction or clicking the "Find Next" button.
 // This isn't documented anywhere useful, like in NSSpellProtocol.h with the
 // other spelling panel methods. This is probably because Apple assumes that the
 // the spelling panel will be used with an NSText, which will automatically
 // catch this and advance to the next word for you. Thanks Apple.
 // This is also called from the Edit -> Spelling -> Check Spelling menu item.
 - (void)checkSpelling:(id)sender {
-  render_widget_host_->Send(new SpellCheckMsg_AdvanceToNextMisspelling(
-      render_widget_host_->routing_id()));
+  renderWidgetHost_->Send(new SpellCheckMsg_AdvanceToNextMisspelling(
+      renderWidgetHost_->routing_id()));
 }
 
 // This message is sent by the spelling panel whenever a word is ignored.
 - (void)ignoreSpelling:(id)sender {
   // Ideally, we would ask the current RenderView for its tag, but that would
   // mean making a blocking IPC call from the browser. Instead,
   // spellcheck_mac::CheckSpelling remembers the last tag and
   // spellcheck_mac::IgnoreWord assumes that is the correct tag.
   NSString* wordToIgnore = [sender stringValue];
   if (wordToIgnore != nil)
     spellcheck_mac::IgnoreWord(base::SysNSStringToUTF16(wordToIgnore));
 }
 
 - (void)showGuessPanel:(id)sender {
-  render_widget_host_->Send(new SpellCheckMsg_ToggleSpellPanel(
-      render_widget_host_->routing_id(),
+  renderWidgetHost_->Send(new SpellCheckMsg_ToggleSpellPanel(
+      renderWidgetHost_->routing_id(),
       spellcheck_mac::SpellingPanelVisible()));
 }
 
 - (void)toggleContinuousSpellChecking:(id)sender {
-  render_widget_host_->Send(
-      new SpellCheckMsg_ToggleSpellCheck(render_widget_host_->routing_id()));
+  renderWidgetHost_->Send(
+      new SpellCheckMsg_ToggleSpellCheck(renderWidgetHost_->routing_id()));
 }
 
 - (void)spellCheckEnabled:(BOOL)enabled checked:(BOOL)checked {
-  spellcheck_enabled_ = enabled;
-  spellcheck_checked_ = checked;
+  spellcheckEnabled_ = enabled;
+  spellcheckChecked_ = checked;
 }
 
 // END Spellchecking methods
 
 @end