Show a different icon in the launcher for incognito windows

chrome/browser/ui/views/ash/launcher/launcher_updater.cc

 // 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.
 
 #include "chrome/browser/ui/views/ash/launcher/launcher_updater.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/shell.h"
 #include "ash/wm/window_util.h"
@@ skipping 10 matching lines @@
 #include "grit/ui_resources.h"
 #include "ui/aura/window.h"
 #include "ui/base/resource/resource_bundle.h"
 
 LauncherUpdater::AppTabDetails::AppTabDetails() : id(0) {
 }
 
 LauncherUpdater::AppTabDetails::~AppTabDetails() {
 }
 
 LauncherUpdater::LauncherUpdater(aura::Window* window,

[sky, 2012/03/09 22:40:46]

A LauncherUpdater is always going to be associated with an incognito or
non-incognito profile. It's cleaner to check it and set it as const on the class
in the constructor from the tabmodel.

[Zachary Kuznia, 2012/03/09 23:23:10]

Done.

                                  TabStripModel* tab_model,
                                  ChromeLauncherDelegate* delegate,
                                  Type type,
                                  const std::string& app_id)
     : window_(window),
       tab_model_(tab_model),
       launcher_delegate_(delegate),
       type_(type),
       app_id_(app_id),
       item_id_(-1) {
@@ skipping 10 matching lines @@
 void LauncherUpdater::Init() {
   tab_model_->AddObserver(this);
   if (type_ == TYPE_APP || type_ == TYPE_PANEL) {
     // App type never changes, create the launcher item immediately.
     ChromeLauncherDelegate::AppType app_type =
         type_ == TYPE_PANEL ? ChromeLauncherDelegate::APP_TYPE_PANEL
         : ChromeLauncherDelegate::APP_TYPE_WINDOW;
     item_id_ = launcher_delegate_->CreateAppLauncherItem(
         this, app_id_, app_type);
   } else {
+    bool is_private = false;
     // Determine if we have any tabs that should get launcher items.
     std::vector<TabContentsWrapper*> app_tabs;
     for (int i = 0; i < tab_model_->count(); ++i) {
       TabContentsWrapper* tab = tab_model_->GetTabContentsAt(i);
       if (!launcher_delegate_->GetAppID(tab).empty())
         app_tabs.push_back(tab);
+      else if (tab->profile()->GetOriginalProfile() != tab->profile())
+        is_private = true;
     }
 
     if (static_cast<int>(app_tabs.size()) != tab_model_->count())
-      CreateTabbedItem();
+      CreateTabbedItem(is_private);
 
     // Create items for the app tabs.
     for (size_t i = 0; i < app_tabs.size(); ++i)
       AddAppItem(app_tabs[i]);
   }
   UpdateLauncher(tab_model_->GetActiveTabContents());
 }
 
 // static
 LauncherUpdater* LauncherUpdater::Create(Browser* browser) {
@@ skipping 138 matching lines @@
         item.image = *ResourceBundle::GetSharedInstance().GetBitmapNamed(
             IDR_DEFAULT_FAVICON);
       }
     }
   }
   launcher_model()->Set(item_index, item);
 }
 
 void LauncherUpdater::UpdateAppTabState(TabContentsWrapper* tab,
                                         UpdateType update_type) {
+  bool is_incognito = (tab->profile()->GetOriginalProfile() != tab->profile());
   bool showing_app_item = app_map_.find(tab) != app_map_.end();
   std::string app_id = update_type == UPDATE_TAB_REMOVED ?
       std::string() : launcher_delegate_->GetAppID(tab);
   bool show_app = !app_id.empty();
   if (showing_app_item == show_app) {
     if (!show_app) {
       if (item_id_ == -1 && update_type == UPDATE_TAB_INSERTED) {
         // A new non-app tab was added and we have no app tabs. Add one now.
-        CreateTabbedItem();
+        CreateTabbedItem(is_incognito);
       } else if (item_id_ != -1 && update_type == UPDATE_TAB_REMOVED &&
                  tab_model_->count() == (static_cast<int>(app_map_.size()))) {
         launcher_delegate_->LauncherItemClosed(item_id_);
         item_id_ = -1;
       }
       return;
     }
 
     if (app_id != app_map_[tab].app_id) {
       // The extension changed.
@@ skipping 14 matching lines @@
          (tab_model_->count() != 1 &&
           tab_model_->count() == (static_cast<int>(app_map_.size()) + 1)))) {
       if (!launcher_delegate_->IsPinned(launcher_id)) {
         // Swap the item for a tabbed item.
         item_id_ = launcher_id;
         launcher_delegate_->ConvertAppToTabbed(item_id_);
       } else {
         // If the app is pinned we have to leave it and create a new tabbed
         // item.
         launcher_delegate_->LauncherItemClosed(launcher_id);
-        CreateTabbedItem();
+        CreateTabbedItem(is_incognito);
       }
-      ash::LauncherItem item(ash::TYPE_TABBED);
+      ash::LauncherItem item;
+      item.type = ash::TYPE_TABBED;
+      item.is_incognito = is_incognito;
       item.num_tabs = tab_model_->count();
       launcher_model()->Set(launcher_model()->ItemIndexByID(item_id_), item);
     } else {
       // We have a tabbed item, so we can remove the the app item.
       launcher_delegate_->LauncherItemClosed(launcher_id);
     }
   } else {
     // Going from not showing to showing.
     if (item_id_ != -1 &&
         static_cast<int>(app_map_.size()) + 1 == tab_model_->count()) {
@@ skipping 28 matching lines @@
 }
 
 void LauncherUpdater::RegisterAppItem(ash::LauncherID id,
                                       TabContentsWrapper* tab) {
   AppTabDetails details;
   details.id = id;
   details.app_id = launcher_delegate_->GetAppID(tab);
   app_map_[tab] = details;
 }
 
-void LauncherUpdater::CreateTabbedItem() {
+void LauncherUpdater::CreateTabbedItem(bool is_private) {
   DCHECK_EQ(-1, item_id_);
-  item_id_ = launcher_delegate_->CreateTabbedLauncherItem(this);
+  item_id_ = launcher_delegate_->CreateTabbedLauncherItem(
+      this,
+      is_private ? ChromeLauncherDelegate::STATE_INCOGNITO :
+                   ChromeLauncherDelegate::STATE_NOT_INCOGNITO);
 }
 
 bool LauncherUpdater::ContainsID(ash::LauncherID id, TabContentsWrapper** tab) {
   if (item_id_ == id)
     return true;
   for (AppTabMap::const_iterator i = app_map_.begin(); i != app_map_.end();
        ++i) {
     if (i->second.id == id) {
       *tab = i->first;
       return true;
     }
   }
   return false;
 }
 
 ash::LauncherModel* LauncherUpdater::launcher_model() {
   return launcher_delegate_->model();
 }