Remove the browser_sync flag.

chrome/browser/views/bookmark_bar_view.cc

 // Copyright (c) 2009 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 96 matching lines @@
 
 // Left-padding for the instructional text.
 static const int kInstructionsPadding = 6;
 
 // Color of the instructional text.
 static const SkColor kInstructionsColor = SkColorSetRGB(128, 128, 142);
 
 // Tag for the 'Other bookmarks' button.
 static const int kOtherFolderButtonTag = 1;
 
-#if defined(BROWSER_SYNC)
 // Tag for the sync error button.
 static const int kSyncErrorButtonTag = 2;
-#endif
 
 namespace {
 
 // Returns the tooltip text for the specified url and title. The returned
 // text is clipped to fit within the bounds of the monitor.
 //
 // Note that we adjust the direction of both the URL and the title based on the
 // locale so that pure LTR strings are displayed properly in RTL locales.
 static std::wstring CreateToolTipForURLAndTitle(const gfx::Point& screen_loc,
                                                 const GURL& url,
@@ skipping 232 matching lines @@
 
 BookmarkBarView::BookmarkBarView(Profile* profile, Browser* browser)
     : profile_(NULL),
       page_navigator_(NULL),
       model_(NULL),
       bookmark_menu_(NULL),
       bookmark_drop_menu_(NULL),
       other_bookmarked_button_(NULL),
       model_changed_listener_(NULL),
       show_folder_drop_menu_task_(NULL),
-#if defined(BROWSER_SYNC)
       sync_error_button_(NULL),
       sync_service_(NULL),
-#endif
       overflow_button_(NULL),
       instructions_(NULL),
       bookmarks_separator_view_(NULL),
       browser_(browser),
       throbbing_view_(NULL) {
-#if defined(BROWSER_SYNC)
   if (profile->GetProfileSyncService()) {
     // Obtain a pointer to the profile sync service and add our instance as an
     // observer.
     sync_service_ = profile->GetProfileSyncService();
     sync_service_->AddObserver(this);
   }
-#endif
 
   SetID(VIEW_ID_BOOKMARK_BAR);
   Init();
   SetProfile(profile);
 
   if (IsAlwaysShown())
     size_animation_->Reset(1);
   else
     size_animation_->Reset(0);
 }
 
 BookmarkBarView::~BookmarkBarView() {
   NotifyModelChanged();
   if (model_)
     model_->RemoveObserver(this);
   StopShowFolderDropMenuTimer();
 
-#if defined(BROWSER_SYNC)
   if (sync_service_)
     sync_service_->RemoveObserver(this);
-#endif
 }
 
 void BookmarkBarView::SetProfile(Profile* profile) {
   DCHECK(profile);
   if (profile_ == profile)
     return;
 
   StopThrobbing(true);
 
   // Cancels the current cancelable.
@@ skipping 38 matching lines @@
   // Bookmarks" folder, along with appropriate margins and button padding.
   int width = kLeftMargin;
 
   if (OnNewTabPage()) {
     double current_state = 1 - size_animation_->GetCurrentValue();
     width += 2 * static_cast<int>(static_cast<double>
         (kNewtabHorizontalPadding) * current_state);
   }
 
   int sync_error_total_width = 0;
-#if defined(BROWSER_SYNC)
   gfx::Size sync_error_button_pref = sync_error_button_->GetPreferredSize();
   if (ShouldShowSyncErrorButton())
     sync_error_total_width += kButtonPadding + sync_error_button_pref.width();
-#endif
 
   gfx::Size other_bookmarked_pref =
       other_bookmarked_button_->GetPreferredSize();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
 
   width += (other_bookmarked_pref.width() + kButtonPadding +
       overflow_pref.width() + kButtonPadding +
       bookmarks_separator_pref.width() + sync_error_total_width);
@@ skipping 227 matching lines @@
   DCHECK(role);
 
   *role = AccessibilityTypes::ROLE_TOOLBAR;
   return true;
 }
 
 void BookmarkBarView::SetAccessibleName(const std::wstring& name) {
   accessible_name_.assign(name);
 }
 
-#if defined(BROWSER_SYNC)
 void BookmarkBarView::OnStateChanged() {
   // When the sync state changes, it is sufficient to invoke View::Layout since
   // during layout we query the profile sync service and determine whether the
   // new state requires showing the sync error button so that the user can
   // re-enter her password. If extension shelf appears along with the bookmark
   // shelf, it too needs to be layed out. Since both have the same parent, it is
   // enough to let the parent layout both of these children.
   // TODO(sky): This should not require Layout() and SchedulePaint(). Needs
   //            some cleanup.
   PreferredSizeChanged();
   Layout();
   SchedulePaint();
 }
-#endif  // defined(BROWSER_SYNC)
 
 void BookmarkBarView::OnFullscreenToggled(bool fullscreen) {
   if (!fullscreen)
     size_animation_->Reset(IsAlwaysShown() ? 1 : 0);
   else if (IsAlwaysShown())
     size_animation_->Reset(0);
 }
 
 bool BookmarkBarView::IsDetached() const {
   return OnNewTabPage() && (size_animation_->GetCurrentValue() != 1);
@@ skipping 125 matching lines @@
   // added in this function.
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
   if (!kDefaultFavIcon)
     kDefaultFavIcon = rb.GetBitmapNamed(IDR_DEFAULT_FAVICON);
 
   other_bookmarked_button_ = CreateOtherBookmarkedButton();
   AddChildView(other_bookmarked_button_);
 
-#if defined(BROWSER_SYNC)
   sync_error_button_ = CreateSyncErrorButton();
   AddChildView(sync_error_button_);
-#endif
 
   overflow_button_ = CreateOverflowButton();
   AddChildView(overflow_button_);
 
   bookmarks_separator_view_ = new ButtonSeparatorView();
   bookmarks_separator_view_->SetAccessibleName(
       l10n_util::GetString(IDS_ACCNAME_SEPARATOR));
   AddChildView(bookmarks_separator_view_);
 
   instructions_ = new views::Label(
@@ skipping 35 matching lines @@
 
   // Make visible as necessary.
   button->SetVisible(false);
   // Set accessibility name.
   button->SetAccessibleName(
       l10n_util::GetString(IDS_ACCNAME_BOOKMARKS_CHEVRON));
   return button;
 }
 
 int BookmarkBarView::GetBookmarkButtonCount() {
-#if defined(BROWSER_SYNC)
   // We contain at least four non-bookmark button views: other bookmarks,
   // bookmarks separator, chevrons (for overflow), the instruction label and
   // the sync error button.
   return GetChildViewCount() - 5;
-#else
-  // We contain at least four non-bookmark button views: other bookmarks,
-  // bookmarks separator, chevrons (for overflow) and the instruction label.
-  return GetChildViewCount() - 4;
-#endif
 }
 
 void BookmarkBarView::Loaded(BookmarkModel* model) {
   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);
@@ skipping 194 matching lines @@
 
   bookmark_menu_ = new BookmarkMenuController(
       browser_, profile_, page_navigator_, GetWindow()->GetNativeWindow(),
       node, start_index, false);
   bookmark_menu_->set_observer(this);
   bookmark_menu_->RunMenuAt(this, false);
 }
 
 void BookmarkBarView::ButtonPressed(views::Button* sender,
                                     const views::Event& event) {
-#if defined(BROWSER_SYNC)
   // Show the login wizard if the user clicked the re-login button.
   if (sender->tag() == kSyncErrorButtonTag) {
     DCHECK(sender == sync_error_button_);
     DCHECK(sync_service_);
     sync_service_->ShowLoginDialog();
     return;
   }
-#endif
 
   const BookmarkNode* node;
   if (sender->tag() == kOtherFolderButtonTag) {
     node = model_->other_node();
   } else {
     int index = GetChildIndex(sender);
     DCHECK_NE(-1, index);
     node = model_->GetBookmarkBarNode()->GetChild(index);
   }
   DCHECK(page_navigator_);
@@ skipping 402 matching lines @@
         (kSeparatorMargin) * current_state);
   }
 
   gfx::Size other_bookmarked_pref =
       other_bookmarked_button_->GetPreferredSize();
   gfx::Size overflow_pref = overflow_button_->GetPreferredSize();
   gfx::Size bookmarks_separator_pref =
       bookmarks_separator_view_->GetPreferredSize();
 
   int sync_error_total_width = 0;
-#if defined(BROWSER_SYNC)
   gfx::Size sync_error_button_pref = sync_error_button_->GetPreferredSize();
   const bool should_show_sync_error_button = ShouldShowSyncErrorButton();
   if (should_show_sync_error_button) {
     sync_error_total_width += kButtonPadding + sync_error_button_pref.width();
   }
-#endif
   const int max_x = width - other_bookmarked_pref.width() - kButtonPadding -
       overflow_pref.width() - kButtonPadding -
       bookmarks_separator_pref.width() - sync_error_total_width;
 
   // Next, layout out the buttons. Any buttons that are placed beyond the
   // visible region and made invisible.
   if (GetBookmarkButtonCount() == 0 && model_ && model_->IsLoaded()) {
     gfx::Size pref = instructions_->GetPreferredSize();
     if (!compute_bounds_only) {
       instructions_->SetBounds(
@@ skipping 48 matching lines @@
 
   x += bookmarks_separator_pref.width();
 
   // The other bookmarks button.
   if (!compute_bounds_only) {
     other_bookmarked_button_->SetBounds(x, y, other_bookmarked_pref.width(),
                                         height);
   }
   x += other_bookmarked_pref.width() + kButtonPadding;
 
-#if defined(BROWSER_SYNC)
   // Set the real bounds of the sync error button only if it needs to appear on
   // the bookmarks bar.
   if (should_show_sync_error_button) {
     x += kButtonPadding;
     if (!compute_bounds_only) {
       sync_error_button_->SetBounds(
           x, y, sync_error_button_pref.width(), height);
       sync_error_button_->SetVisible(true);
     }
     x += sync_error_button_pref.width();
   } else if (!compute_bounds_only) {
     sync_error_button_->SetBounds(x, y, 0, height);
     sync_error_button_->SetVisible(false);
   }
-#endif  // defined(BROWSER_SYNC)
 
   // Set the preferred size computed so far.
   if (compute_bounds_only) {
     x += kRightMargin;
     prefsize.set_width(x);
     if (OnNewTabPage()) {
       x += static_cast<int>(static_cast<double>(kNewtabHorizontalPadding) *
           (1 - size_animation_->GetCurrentValue()));
       prefsize.set_height(kBarHeight + static_cast<int>(static_cast<double>
                           (kNewtabBarHeight - kBarHeight) *
                           (1 - size_animation_->GetCurrentValue())));
     } else {
       prefsize.set_height(static_cast<int>(static_cast<double>(kBarHeight) *
                           size_animation_->GetCurrentValue()));
     }
   }
   return prefsize;
 }
 
-#if defined(BROWSER_SYNC)
 // The sync state reported by the profile sync service determines whether or
 // not the re-login indicator button should be visible.
 bool BookmarkBarView::ShouldShowSyncErrorButton() {
   bool show_sync_error_button(false);
   if (sync_service_ && sync_service_->HasSyncSetupCompleted()) {
     string16 status_text;
     string16 link_text;
     SyncStatusUIHelper::MessageType sync_status;
     sync_status = SyncStatusUIHelper::GetLabels(
         sync_service_, &status_text, &link_text);
@@ skipping 13 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;
 }
-#endif  // defined(BROWSER_SYNC)