Removes debugging code added in hopes of finding crasher. The crash

chrome/browser/views/bookmark_bar_view.cc

 // Copyright (c) 2010 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 "chrome/browser/views/bookmark_bar_view.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 935 matching lines @@
   // Make visible as necessary.
   button->SetVisible(false);
   // Set accessibility name.
   button->SetAccessibleName(
       l10n_util::GetString(IDS_ACCNAME_BOOKMARKS_CHEVRON));
   return button;
 }
 
 void BookmarkBarView::Loaded(BookmarkModel* model) {
   volatile int button_count = GetBookmarkButtonCount();
-  CHECK(button_count == 0);  // If non-zero it means Load was invoked more than
-                             // once, or we didn't properly clear things. Either
-                             // of which shouldn't happen
+  DCHECK(button_count == 0);  // If non-zero it means Load was invoked more than
+                              // once, or we didn't properly clear things.
+                              // Either of which shouldn't happen
   const BookmarkNode* node = model_->GetBookmarkBarNode();
   DCHECK(node && model_->other_node());
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0, child_count = node->GetChildCount(); i < child_count; ++i)
     AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
   UpdateColors();
   other_bookmarked_button_->SetEnabled(true);
 
   Layout();
   SchedulePaint();
-
-  CheckIntegrity();
 }
 
 void BookmarkBarView::BookmarkModelBeingDeleted(BookmarkModel* model) {
   // The bookmark model should never be deleted before us. This code exists
   // to check for regressions in shutdown code and not crash.
   NOTREACHED();
 
   // Do minimal cleanup, presumably we'll be deleted shortly.
   NotifyModelChanged();
   model_->RemoveObserver(this);
   model_ = NULL;
 }
 
 void BookmarkBarView::BookmarkNodeMoved(BookmarkModel* model,
                                         const BookmarkNode* old_parent,
                                         int old_index,
                                         const BookmarkNode* new_parent,
                                         int new_index) {
   BookmarkNodeRemovedImpl(model, old_parent, old_index);
   BookmarkNodeAddedImpl(model, new_parent, new_index);
-  CheckIntegrity();
 }
 
 void BookmarkBarView::BookmarkNodeAdded(BookmarkModel* model,
                                         const BookmarkNode* parent,
                                         int index) {
   BookmarkNodeAddedImpl(model, parent, index);
-  CheckIntegrity();
 }
 
 void BookmarkBarView::BookmarkNodeAddedImpl(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
   const BookmarkNode* node = parent->GetChild(index);
   if (!throbbing_view_ && sync_service_ && sync_service_->SetupInProgress()) {
     StartThrobbing(node, true);
   }
   AddChildView(index, CreateBookmarkButton(node));
   UpdateColors();
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeRemoved(BookmarkModel* model,
                                           const BookmarkNode* parent,
                                           int old_index,
                                           const BookmarkNode* node) {
   BookmarkNodeRemovedImpl(model, parent, old_index);
-  CheckIntegrity();
 }
 
 void BookmarkBarView::BookmarkNodeRemovedImpl(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index) {
   StopThrobbing(true);
   // No need to start throbbing again as the bookmark bubble can't be up at
   // the same time as the user reorders.
 
   NotifyModelChanged();
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index < GetBookmarkButtonCount());
   views::View* button = GetChildViewAt(index);
   RemoveChildView(button);
   MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   Layout();
   SchedulePaint();
 }
 
 void BookmarkBarView::BookmarkNodeChanged(BookmarkModel* model,
                                           const BookmarkNode* node) {
   NotifyModelChanged();
   BookmarkNodeChangedImpl(model, node);
-  CheckIntegrity();
 }
 
 void BookmarkBarView::BookmarkNodeChangedImpl(BookmarkModel* model,
                                               const BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model_->GetBookmarkBarNode()->IndexOfChild(node);
   DCHECK_NE(-1, index);
@@ skipping 22 matching lines @@
     MessageLoop::current()->DeleteSoon(FROM_HERE, button);
   }
 
   // Create the new buttons.
   for (int i = 0, child_count = node->GetChildCount(); i < child_count; ++i)
     AddChildView(i, CreateBookmarkButton(node->GetChild(i)));
   UpdateColors();
 
   Layout();
   SchedulePaint();
-
-  CheckIntegrity();
 }
 
 void BookmarkBarView::BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                                 const BookmarkNode* node) {
   BookmarkNodeChangedImpl(model, node);
 }
 
 void BookmarkBarView::WriteDragData(View* sender,
                                     const gfx::Point& press_pt,
                                     OSExchangeData* data) {
@@ skipping 17 matching lines @@
 int BookmarkBarView::GetDragOperations(View* sender, const gfx::Point& p) {
   if (size_animation_->is_animating() ||
       (size_animation_->GetCurrentValue() == 0 && !OnNewTabPage())) {
     // Don't let the user drag while animating open or we're closed (and not on
     // the new tab page, on the new tab page size_animation_ is always 0). This
     // typically is only hit if the user does something to inadvertanty trigger
     // dnd, such as pressing the mouse and hitting control-b.
     return DragDropTypes::DRAG_NONE;
   }
 
-  CheckIntegrity();
-
   for (int i = 0; i < GetBookmarkButtonCount(); ++i) {
     if (sender == GetBookmarkButton(i)) {
       return bookmark_utils::BookmarkDragOperation(
           model_->GetBookmarkBarNode()->GetChild(i));
     }
   }
   NOTREACHED();
   return DragDropTypes::DRAG_NONE;
 }
 
@@ skipping 587 matching lines @@
   // The tooltip is the only way we have to display text explaining the error
   // to the user.
   sync_error_button->SetTooltipText(
       l10n_util::GetString(IDS_SYNC_BOOKMARK_BAR_ERROR_DESC));
   sync_error_button->SetAccessibleName(
       l10n_util::GetString(IDS_ACCNAME_SYNC_ERROR_BUTTON));
   sync_error_button->SetIcon(
       *ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING));
   return sync_error_button;
 }
-
-void BookmarkBarView::CheckIntegrity() {
-  // We better be on the ui thread.
-  CHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
-
-  // And the number of views on the bookmark bar better match that of the model.
-  volatile int model_count = model_->GetBookmarkBarNode()->GetChildCount();
-  volatile int view_count = GetBookmarkButtonCount();
-  CHECK_EQ(model_count, view_count);
-}