Make chromeos build use shared object to load battery...

chrome/browser/chromeos/status_area_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/chromeos/status_area_view.h"
 
 #include <algorithm>
+#include <dlfcn.h>
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/font.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/theme_provider.h"
+#include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_window.h"
+#include "chrome/common/chrome_paths.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/profile.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/image_view.h"
 #include "views/controls/menu/menu.h"
 #include "views/controls/menu/simple_menu_model.h"
 
 namespace {
 
+// The number of images representing the fullness of the battery.
+const int kNumBatteryImages = 8;
+
 // Number of pixels to separate adjacent status items.
 const int kStatusItemSeparation = 1;
 
 class ClockView : public views::View {
  public:
   ClockView();
   virtual ~ClockView();
 
   // views::View* overrides.
   virtual gfx::Size GetPreferredSize();
@@ skipping 12 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ClockView);
 };
 
 // Amount of slop to add into the timer to make sure we're into the next minute
 // when the timer goes off.
 const int kTimerSlopSeconds = 1;
 
 ClockView::ClockView()
     : font_(ResourceBundle::GetSharedInstance().GetFont(
-                ResourceBundle::BaseFont)) {
+                ResourceBundle::BaseFont).DeriveFont(0, gfx::Font::BOLD)) {
   SetNextTimer();
 }
 
 ClockView::~ClockView() {
 }
 
 gfx::Size ClockView::GetPreferredSize() {
-  return gfx::Size(40, 10);
+  return gfx::Size(40, 12);
 }
 
 void ClockView::Paint(gfx::Canvas* canvas) {
   base::Time now = base::Time::Now();
   base::Time::Exploded now_exploded;
   now.LocalExplode(&now_exploded);
+  int hour = now_exploded.hour % 12;
+  if (hour == 0)
+    hour = 12;
 
-  std::wstring time_string = StringPrintf(L"%d:%02d",
-                                          now_exploded.hour,
-                                          now_exploded.minute);
+  std::wstring time_string = StringPrintf(L"%d:%02d%lc",
+                                          hour,
+                                          now_exploded.minute,
+                                          now_exploded.hour < 12 ? L'p' : L'p');
   canvas->DrawStringInt(time_string, font_, SK_ColorWHITE, 0, 0,
                         width(), height(), gfx::Canvas::TEXT_ALIGN_CENTER);
 }
 
 void ClockView::SetNextTimer() {
   // Try to set the timer to go off at the next change of the minute. We don't
   // want to have the timer go off more than necessary since that will cause
   // the CPU to wake up and consume power.
   base::Time now = base::Time::Now();
   base::Time::Exploded exploded;
@@ skipping 85 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(OptionsMenuModel);
 };
 
 }  // namespace
 
 // Default to opening new tabs on the left.
 StatusAreaView::OpenTabsMode StatusAreaView::open_tabs_mode_ =
     StatusAreaView::OPEN_TABS_ON_LEFT;
 
+// static
+void* StatusAreaView::power_library_ = NULL;
+bool StatusAreaView::power_library_error_ = false;
+
 StatusAreaView::StatusAreaView(Browser* browser)
     : browser_(browser),
       battery_view_(NULL),
-      menu_view_(NULL) {
+      menu_view_(NULL),
+      power_status_connection_(NULL) {
 }
 
 StatusAreaView::~StatusAreaView() {
+  if (power_status_connection_)
+    chromeos::DisconnectPowerStatus(power_status_connection_);
 }
 
 void StatusAreaView::Init() {
-  ResourceBundle& resource_bundle = ResourceBundle::GetSharedInstance();
-
-  // Battery.
-  battery_view_ = new views::ImageView;
-  battery_view_->SetImage(
-      resource_bundle.GetBitmapNamed(IDR_STATUSBAR_BATTERY));
-  AddChildView(battery_view_);
+  LoadPowerLibrary();
+  ThemeProvider* theme = browser_->profile()->GetThemeProvider();
 
   // Clock.
   AddChildView(new ClockView);
 
+  // Battery.
+  battery_view_ = new views::ImageView;
+  battery_view_->SetImage(theme->GetBitmapNamed(IDR_STATUSBAR_BATTERY_UNKNOWN));
+  AddChildView(battery_view_);
+
   // Menu.
   menu_view_ = new views::MenuButton(NULL, std::wstring(), this, false);
-  menu_view_->SetIcon(*resource_bundle.GetBitmapNamed(IDR_STATUSBAR_MENU));
+  menu_view_->SetIcon(*theme->GetBitmapNamed(IDR_STATUSBAR_MENU));
   AddChildView(menu_view_);
+
+  if (power_library_) {
+    power_status_connection_ = chromeos::MonitorPowerStatus(
+        StatusAreaView::PowerStatusChangedHandler,
+        this);
+  }
 }
 
 gfx::Size StatusAreaView::GetPreferredSize() {
   int result_w = kStatusItemSeparation;  // Left border.
   int result_h = 0;
   for (int i = 0; i < GetChildViewCount(); i++) {
     gfx::Size cur_size = GetChildViewAt(i)->GetPreferredSize();
     result_w += cur_size.width() + kStatusItemSeparation;
     result_h = std::max(result_h, cur_size.height());
   }
@@ skipping 101 matching lines @@
 
 void StatusAreaView::ExecuteCommand(int command_id) {
   browser_->ExecuteCommand(command_id);
 }
 
 void StatusAreaView::RunMenu(views::View* source, const gfx::Point& pt,
                              gfx::NativeView hwnd) {
   CreateAppMenu();
   app_menu_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
 }
+
+// static
+void StatusAreaView::LoadPowerLibrary() {
+  if (power_library_) {
+    // Already loaded.
+    return;
+  }
+
+  if (power_library_error_) {
+    // Error in previous load attempt.
+    return;
+  }
+
+  FilePath path;
+  if (PathService::Get(chrome::FILE_CHROMEOS_API, &path)) {
+    power_library_ = dlopen(path.value().c_str(), RTLD_NOW);
+    if (power_library_) {
+      chromeos::LoadPower(power_library_);
+    } else {
+      power_library_error_ = true;
+      char* error = dlerror();
+      if (error) {
+        LOG(ERROR) << "Problem loading chromeos shared object: " << error;
+      }
+    }
+  }
+}
+
+// static
+void StatusAreaView::PowerStatusChangedHandler(
+    void* object, const chromeos::PowerStatus& status) {
+  static_cast<StatusAreaView*>(object)->PowerStatusChanged(status);
+}
+
+void StatusAreaView::PowerStatusChanged(const chromeos::PowerStatus& status) {
+  ThemeProvider* theme = browser_->profile()->GetThemeProvider();
+  int image_index;
+
+  if (status.battery_state == chromeos::BATTERY_STATE_FULLY_CHARGED &&
+      status.line_power_on) {
+    image_index = IDR_STATUSBAR_BATTERY_CHARGED;
+  } else {
+    image_index = status.line_power_on ?
+        IDR_STATUSBAR_BATTERY_CHARGING_1 :
+        IDR_STATUSBAR_BATTERY_DISCHARGING_1;
+    double percentage = status.battery_percentage;
+    int offset = floor(percentage / (100.0 / kNumBatteryImages));
+    // This can happen if the battery is 100% full.
+    if (offset == kNumBatteryImages)
+      offset--;
+    image_index += offset;
+  }
+  battery_view_->SetImage(theme->GetBitmapNamed(image_index));
+}