chrome/browser/ui/views/status_icons/status_tray_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/views/status_icons/status_tray_win.h"
   6
   7 #include <commctrl.h>
   8
   9 #include "base/bind.h"
  10 #include "base/threading/non_thread_safe.h"
  11 #include "base/threading/thread.h"
  12 #include "base/win/wrapped_window_proc.h"
  13 #include "chrome/browser/ui/views/status_icons/status_icon_win.h"
  14 #include "chrome/browser/ui/views/status_icons/status_tray_state_changer_win.h"
  15 #include "chrome/common/chrome_constants.h"
  16 #include "ui/gfx/screen.h"
  17 #include "ui/gfx/win/hwnd_util.h"
  18
  19 static const UINT kStatusIconMessage = WM_APP + 1;
  20
  21 namespace {
  22 // |kBaseIconId| is 2 to avoid conflicts with plugins that hard-code id 1.
  23 const UINT kBaseIconId = 2;
  24
  25 UINT ReservedIconId(StatusTray::StatusIconType type) {
  26   return kBaseIconId + static_cast<UINT>(type);
  27 }
  28 }  // namespace
  29
  30 // Default implementation for StatusTrayStateChanger that communicates to
  31 // Exporer.exe via COM.  It spawns a background thread with a fresh COM
  32 // apartment and requests that the visibility be increased unless the user
  33 // has explicitly set the icon to be hidden.
  34 class StatusTrayStateChangerProxyImpl : public StatusTrayStateChangerProxy,
  35                                         public base::NonThreadSafe {
  36  public:
  37   StatusTrayStateChangerProxyImpl()
  38       : pending_requests_(0),
  39         worker_thread_("StatusIconCOMWorkerThread"),
  40         weak_factory_(this) {
  41     worker_thread_.init_com_with_mta(false);
  42   }
  43
  44   virtual void EnqueueChange(UINT icon_id, HWND window) OVERRIDE {
  45     DCHECK(CalledOnValidThread());
  46     if (pending_requests_ == 0)
  47       worker_thread_.Start();
  48
  49     ++pending_requests_;
  50     worker_thread_.message_loop_proxy()->PostTaskAndReply(
  51         FROM_HERE,
  52         base::Bind(
  53             &StatusTrayStateChangerProxyImpl::EnqueueChangeOnWorkerThread,
  54             icon_id,
  55             window),
  56         base::Bind(&StatusTrayStateChangerProxyImpl::ChangeDone,
  57                    weak_factory_.GetWeakPtr()));
  58   }
  59
  60  private:
  61   // Must be called only on |worker_thread_|, to ensure the correct COM
  62   // apartment.
  63   static void EnqueueChangeOnWorkerThread(UINT icon_id, HWND window) {
  64     // It appears that IUnknowns are coincidentally compatible with
  65     // scoped_refptr.  Normally I wouldn't depend on that but it seems that
  66     // base::win::IUnknownImpl itself depends on that coincidence so it's
  67     // already being assumed elsewhere.
  68     scoped_refptr<StatusTrayStateChangerWin> status_tray_state_changer(
  69         new StatusTrayStateChangerWin(icon_id, window));
  70     status_tray_state_changer->EnsureTrayIconVisible();
  71   }
  72
  73   // Called on UI thread.
  74   void ChangeDone() {
  75     DCHECK(CalledOnValidThread());
  76     DCHECK_GT(pending_requests_, 0);
  77
  78     if (--pending_requests_ == 0)
  79       worker_thread_.Stop();
  80   }
  81
  82  private:
  83   int pending_requests_;
  84   base::Thread worker_thread_;
  85   base::WeakPtrFactory<StatusTrayStateChangerProxyImpl> weak_factory_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(StatusTrayStateChangerProxyImpl);
  88 };
  89
  90 StatusTrayWin::StatusTrayWin()
  91     : next_icon_id_(1),
  92       atom_(0),
  93       instance_(NULL),
  94       window_(NULL) {
  95   // Register our window class
  96   WNDCLASSEX window_class;
  97   base::win::InitializeWindowClass(
  98       chrome::kStatusTrayWindowClass,
  99       &base::win::WrappedWindowProc<StatusTrayWin::WndProcStatic>,
 100       0, 0, 0, NULL, NULL, NULL, NULL, NULL,
 101       &window_class);
 102   instance_ = window_class.hInstance;
 103   atom_ = RegisterClassEx(&window_class);
 104   CHECK(atom_);
 105
 106   // If the taskbar is re-created after we start up, we have to rebuild all of
 107   // our icons.
 108   taskbar_created_message_ = RegisterWindowMessage(TEXT("TaskbarCreated"));
 109
 110   // Create an offscreen window for handling messages for the status icons. We
 111   // create a hidden WS_POPUP window instead of an HWND_MESSAGE window, because
 112   // only top-level windows such as popups can receive broadcast messages like
 113   // "TaskbarCreated".
 114   window_ = CreateWindow(MAKEINTATOM(atom_),
 115                          0, WS_POPUP, 0, 0, 0, 0, 0, 0, instance_, 0);
 116   gfx::CheckWindowCreated(window_);
 117   gfx::SetWindowUserData(window_, this);
 118 }
 119
 120 StatusTrayWin::~StatusTrayWin() {
 121   if (window_)
 122     DestroyWindow(window_);
 123
 124   if (atom_)
 125     UnregisterClass(MAKEINTATOM(atom_), instance_);
 126 }
 127
 128 void StatusTrayWin::UpdateIconVisibilityInBackground(
 129     StatusIconWin* status_icon) {
 130   if (!state_changer_proxy_.get())
 131     state_changer_proxy_.reset(new StatusTrayStateChangerProxyImpl);
 132
 133   state_changer_proxy_->EnqueueChange(status_icon->icon_id(),
 134                                       status_icon->window());
 135 }
 136
 137 LRESULT CALLBACK StatusTrayWin::WndProcStatic(HWND hwnd,
 138                                               UINT message,
 139                                               WPARAM wparam,
 140                                               LPARAM lparam) {
 141   StatusTrayWin* msg_wnd = reinterpret_cast<StatusTrayWin*>(
 142       GetWindowLongPtr(hwnd, GWLP_USERDATA));
 143   if (msg_wnd)
 144     return msg_wnd->WndProc(hwnd, message, wparam, lparam);
 145   else
 146     return ::DefWindowProc(hwnd, message, wparam, lparam);
 147 }
 148
 149 LRESULT CALLBACK StatusTrayWin::WndProc(HWND hwnd,
 150                                         UINT message,
 151                                         WPARAM wparam,
 152                                         LPARAM lparam) {
 153   if (message == taskbar_created_message_) {
 154     // We need to reset all of our icons because the taskbar went away.
 155     for (StatusIcons::const_iterator i(status_icons().begin());
 156          i != status_icons().end(); ++i) {
 157       StatusIconWin* win_icon = static_cast<StatusIconWin*>(*i);
 158       win_icon->ResetIcon();
 159     }
 160     return TRUE;
 161   } else if (message == kStatusIconMessage) {
 162     StatusIconWin* win_icon = NULL;
 163
 164     // Find the selected status icon.
 165     for (StatusIcons::const_iterator i(status_icons().begin());
 166          i != status_icons().end();
 167          ++i) {
 168       StatusIconWin* current_win_icon = static_cast<StatusIconWin*>(*i);
 169       if (current_win_icon->icon_id() == wparam) {
 170         win_icon = current_win_icon;
 171         break;
 172       }
 173     }
 174
 175     // It is possible for this procedure to be called with an obsolete icon
 176     // id.  In that case we should just return early before handling any
 177     // actions.
 178     if (!win_icon)
 179       return TRUE;
 180
 181     switch (lparam) {
 182       case TB_INDETERMINATE:
 183         win_icon->HandleBalloonClickEvent();
 184         return TRUE;
 185
 186       case WM_LBUTTONDOWN:
 187       case WM_RBUTTONDOWN:
 188       case WM_CONTEXTMENU:
 189         // Walk our icons, find which one was clicked on, and invoke its
 190         // HandleClickEvent() method.
 191         gfx::Point cursor_pos(
 192             gfx::Screen::GetNativeScreen()->GetCursorScreenPoint());
 193         win_icon->HandleClickEvent(cursor_pos, lparam == WM_LBUTTONDOWN);
 194         return TRUE;
 195     }
 196   }
 197   return ::DefWindowProc(hwnd, message, wparam, lparam);
 198 }
 199
 200 StatusIcon* StatusTrayWin::CreatePlatformStatusIcon(
 201     StatusTray::StatusIconType type,
 202     const gfx::ImageSkia& image,
 203     const base::string16& tool_tip) {
 204   UINT next_icon_id;
 205   if (type == StatusTray::OTHER_ICON)
 206     next_icon_id = NextIconId();
 207   else
 208     next_icon_id = ReservedIconId(type);
 209
 210   StatusIcon* icon =
 211       new StatusIconWin(this, next_icon_id, window_, kStatusIconMessage);
 212
 213   icon->SetImage(image);
 214   icon->SetToolTip(tool_tip);
 215   return icon;
 216 }
 217
 218 UINT StatusTrayWin::NextIconId() {
 219   UINT icon_id = next_icon_id_++;
 220   return kBaseIconId + static_cast<UINT>(NAMED_STATUS_ICON_COUNT) + icon_id;
 221 }
 222
 223 void StatusTrayWin::SetStatusTrayStateChangerProxyForTest(
 224     scoped_ptr<StatusTrayStateChangerProxy> proxy) {
 225   state_changer_proxy_ = proxy.Pass();
 226 }
 227
 228 StatusTray* StatusTray::Create() {
 229   return new StatusTrayWin();
 230 }