This fixes a problem with fav icon opacity, and initial panning position.

layout_manager.cc

 // Copyright (c) 2010 The Chromium OS 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 "window_manager/layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <cstdio>
 #include <tr1/memory>
@@ skipping 64 matching lines @@
       mode_(MODE_ACTIVE),
       x_(0),
       y_(0),
       width_(wm_->width()),
       height_(wm_->height()),
       panel_manager_left_width_(0),
       panel_manager_right_width_(0),
       current_toplevel_(NULL),
       current_snapshot_(NULL),
       fullscreen_toplevel_(NULL),
-      overview_panning_offset_(0),
+      overview_panning_offset_(INT_MAX),
       overview_background_offset_(0),
       overview_width_of_snapshots_(0),
       overview_background_event_coalescer_(
           new MotionEventCoalescer(
               wm_->event_loop(),
               NewPermanentCallback(
                   this, &LayoutManager::UpdateOverviewPanningForMotion),
               kOverviewDragUpdateMs)),
       overview_drag_last_x_(-1),
       saw_map_request_(false),
@@ skipping 746 matching lines @@
 
   if (background_.get())
     background_->MoveX(overview_background_offset_,
                        animate ? kWindowAnimMs : 0);
 
   if (wm_->client_window_debugging_enabled())
     wm_->UpdateClientWindowDebugging();
 }
 
 void LayoutManager::SetMode(Mode mode) {
-  // Just treat the active-cancelled state as regular active mode; we're
-  // really just using it to pass an extra bit of information into this
-  // method so we can notify Chrome that overview mode was cancelled.
+  // Just treat the active-cancelled state as regular active mode;
+  // we're really just using it to pass an extra bit of information
+  // into this method so we can notify Chrome that overview mode was
+  // cancelled.  Cancelling actually happens on the Chrome side, since
+  // it knows what tabs used to be selected.
   bool was_cancelled = false;
   if (mode == MODE_ACTIVE_CANCELLED) {
     was_cancelled = true;
     mode = MODE_ACTIVE;
   }
 
   if (mode == mode_)
     return;
 
   if (wm_->logged_in())
     DisableKeyBindingsForMode(mode_);
 
   mode_ = mode;
   DLOG(INFO) << "Switching to " << GetModeName(mode_) << " mode";
 
   switch (mode_) {
     case MODE_ACTIVE:
-      // Cancelling actually happens on the Chrome side, since it
-      // knows what tabs used to be selected.  It knows to cancel
-      // because it's a different layout mode.
       if (current_toplevel_)
         current_toplevel_->TakeFocus(wm_->GetCurrentTimeFromServer());
       for (ToplevelWindows::iterator it = toplevels_.begin();
            it != toplevels_.end(); ++it) {
         if (it->get() == current_toplevel_) {
           (*it)->SetState(ToplevelWindow::STATE_ACTIVE_MODE_IN_FADE);
         } else {
           (*it)->SetState(ToplevelWindow::STATE_ACTIVE_MODE_OFFSCREEN);
         }
       }
       for (SnapshotWindows::iterator it = snapshots_.begin();
            it != snapshots_.end(); ++it) {
         (*it)->SetState(SnapshotWindow::STATE_ACTIVE_MODE_INVISIBLE);
       }
       for (Separators::iterator it = separators_.begin();
            it != separators_.end(); ++it) {
         (*it)->SetState(Separator::STATE_ACTIVE_MODE_INVISIBLE);
       }
       break;
     case MODE_OVERVIEW: {
       UpdateCurrentSnapshot();
+
       if (current_toplevel_ &&
           current_toplevel_->IsWindowOrTransientFocused()) {
         // We need to give the input focus away here; otherwise the
         // previously-focused window would continue to get keyboard events
         // in overview mode.  Let the WindowManager decide what to do with it.
         wm_->TakeFocus(wm_->GetCurrentTimeFromServer());
       }
 
       for (ToplevelWindows::iterator it = toplevels_.begin();
            it != toplevels_.end(); ++it) {
@@ skipping 346 matching lines @@
     overview_width_of_snapshots_ = running_width - kOverviewSelectedPadding;
   }
 
   if (enforce_bounds) {
     const float kMargin = width_ * kSideMarginRatio;
     int min_x = kMargin;
     int max_x = width_ - overview_width_of_snapshots_ - kMargin;
     if (max_x < min_x)
       std::swap(max_x, min_x);
 
+    // If we haven't set the panning offset before, center the current
+    // snapshot.
+    if (overview_panning_offset_ == INT_MAX)
+      CenterCurrentSnapshot(-1, -1);
+
     // There's two modes here: one where the snapshots are too wide
     // to fit, and one where they aren't.  Just so happens that we
     // want to do similar things in both cases.
     if (overview_panning_offset_ < min_x) {
       overview_panning_offset_ = min_x;
     } else {
       if (snapshots_.size() > 0) {
         if (overview_panning_offset_ > max_x)
           overview_panning_offset_ = max_x;
       } else {
@@ skipping 510 matching lines @@
       PLOG(ERROR) << "Unable to open file "
                   << FLAGS_initial_chrome_window_mapped_file;
     } else {
       fprintf(file, "%lu", win->xid());
       fclose(file);
     }
   }
 }
 
 }  // namespace window_manager