Add 'App Size' to App Info Dialog

chrome/browser/ui/views/apps/app_info_dialog/app_info_summary_panel.cc

 // Copyright 2014 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/apps/app_info_dialog/app_info_summary_panel.h"
 
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/command_line.h"
+#include "base/file_util.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/combobox_model.h"
+#include "ui/base/text/bytes_formatting.h"
 #include "ui/views/controls/combobox/combobox.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 // A model for a combobox selecting the launch options for a hosted app.
 // Displays different options depending on the host OS.
 class LaunchOptionsComboboxModel : public ui::ComboboxModel {
@@ skipping 81 matching lines @@
 }
 
 int LaunchOptionsComboboxModel::GetItemCount() const {
   return launch_types_.size();
 }
 
 base::string16 LaunchOptionsComboboxModel::GetItemAt(int index) {
   return launch_type_messages_[index];
 }
 
+// A buffer for storing the App's size while it's being calculated.
+class AppSizeBuffer : public base::RefCountedThreadSafe<AppSizeBuffer> {
+ public:
+  void SetAppSize(int64 app_size) { app_size_ = app_size; }
+  int64 GetAppSize() { return app_size_; }
+
+ private:
+  friend class base::RefCountedThreadSafe<AppSizeBuffer>;
+  virtual ~AppSizeBuffer() {}
+
+  int64 app_size_;
+};
+
+// Calculates the size of the given path and saves it to the provided buffer.
+void CalculateAppSize(const base::FilePath& path,
+                      scoped_refptr<AppSizeBuffer> app_size_in_bytes) {
+  app_size_in_bytes->SetAppSize(base::ComputeDirectorySize(path));
+}
+
 AppInfoSummaryPanel::AppInfoSummaryPanel(Profile* profile,
                                          const extensions::Extension* app)
     : AppInfoPanel(profile, app),
       description_heading_(NULL),
       description_label_(NULL),
       details_heading_(NULL),
+      size_title_(NULL),
+      size_value_(NULL),
       version_title_(NULL),
       version_value_(NULL),
       installed_time_title_(NULL),
       installed_time_value_(NULL),
       last_run_time_title_(NULL),
       last_run_time_value_(NULL),
-      launch_options_combobox_(NULL) {
+      launch_options_combobox_(NULL),
+      weak_ptr_factory_(this) {
   // Create UI elements.
   CreateDescriptionControl();
   CreateDetailsControl();
   CreateLaunchOptionControl();
 
   // Layout elements.
   SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical,
                            0,
                            0,
@@ skipping 23 matching lines @@
 
     description_heading_ = CreateHeading(
         l10n_util::GetStringUTF16(IDS_APPLICATION_INFO_DESCRIPTION_TITLE));
     description_label_ = new views::Label(text);
     description_label_->SetMultiLine(true);
     description_label_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   }
 }
 
 void AppInfoSummaryPanel::CreateDetailsControl() {
+  // The size doesn't make sense for component apps.
+  if (app_->location() != extensions::Manifest::COMPONENT) {
+    size_title_ = new views::Label(
+        l10n_util::GetStringUTF16(IDS_APPLICATION_INFO_SIZE_LABEL));
+    size_title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+
+    size_value_ = new views::Label(
+        l10n_util::GetStringUTF16(IDS_APPLICATION_INFO_SIZE_LOADING_LABEL));
+    size_value_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+
+    StartCalculatingAppSize();
+  }
+
   // The version doesn't make sense for bookmark apps.
   if (!app_->from_bookmark()) {
     // Display 'Version: Built-in' for component apps.
     base::string16 version_str = base::ASCIIToUTF16(app_->VersionString());
     if (app_->location() == extensions::Manifest::COMPONENT)
       version_str = l10n_util::GetStringUTF16(
           IDS_APPLICATION_INFO_VERSION_BUILT_IN_LABEL);
 
     version_title_ = new views::Label(
         l10n_util::GetStringUTF16(IDS_APPLICATION_INFO_VERSION_LABEL));
@@ skipping 73 matching lines @@
           CreateKeyValueField(version_title_, version_value_));
 
     if (installed_time_title_ && installed_time_value_)
       details_stack->AddChildView(
           CreateKeyValueField(installed_time_title_, installed_time_value_));
 
     if (last_run_time_title_ && last_run_time_value_)
       details_stack->AddChildView(
           CreateKeyValueField(last_run_time_title_, last_run_time_value_));
 
+    if (size_title_ && size_value_)
+      details_stack->AddChildView(
+          CreateKeyValueField(size_title_, size_value_));
+
     views::View* vertical_stack = CreateVerticalStack();
     vertical_stack->AddChildView(details_heading_);
     vertical_stack->AddChildView(details_stack);
     AddChildView(vertical_stack);
   }
 }
 
 void AppInfoSummaryPanel::OnPerformAction(views::Combobox* combobox) {
   if (combobox == launch_options_combobox_) {
     SetLaunchType(launch_options_combobox_model_->GetLaunchTypeAtIndex(
         launch_options_combobox_->selected_index()));
   } else {
     NOTREACHED();
   }
 }
 
+void AppInfoSummaryPanel::StartCalculatingAppSize() {
+  scoped_refptr<AppSizeBuffer> app_size_in_bytes = new AppSizeBuffer();
+  content::BrowserThread::PostTaskAndReply(

[tapted, 2014/07/31 00:42:04]

I think you want PostTaskAndReplyWithResult. Also the FILE thread is pretty
clogged - I think new code is meant to use the blocking pool. I think it would
look something like

  base::PostTaskAndReplyWithResult(
      BrowserThread::GetBlockingPool(),
      FROM_HERE,
      base::Bind(&base::ComputeDirectorySize, app_->path()),
      base::Bind(&AppInfoSummaryPanel::OnAppSizeCalculated, AsWeakPtr()));

[sashab, 2014/07/31 05:00:46]

Nice! Saves so much code. Strange how there are different base:: and
BrowerThread:: PostTaskAndReplyWithResult... Anyway, done :)

+      content::BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&CalculateAppSize, app_->path(), app_size_in_bytes),
+      base::Bind(&AppInfoSummaryPanel::OnAppSizeCalculated,
+                 AsWeakPtr(),
+                 app_size_in_bytes));
+}
+
+void AppInfoSummaryPanel::OnAppSizeCalculated(

[tapted, 2014/07/31 00:42:04]

Then this can just take an an int64 argument

[sashab, 2014/07/31 05:00:46]

Yup, done.

+    scoped_refptr<AppSizeBuffer> app_size_in_bytes) {
+  size_value_->SetText(ui::FormatBytes(app_size_in_bytes->GetAppSize()));
+}
+
 base::Time AppInfoSummaryPanel::GetInstalledTime() const {
   return extensions::ExtensionPrefs::Get(profile_)->GetInstallTime(app_->id());
 }
 
 base::Time AppInfoSummaryPanel::GetLastLaunchedTime() const {
   return extensions::ExtensionPrefs::Get(profile_)
       ->GetLastLaunchTime(app_->id());
 }
 
 extensions::LaunchType AppInfoSummaryPanel::GetLaunchType() const {
   return extensions::GetLaunchType(extensions::ExtensionPrefs::Get(profile_),
                                    app_);
 }
 
 void AppInfoSummaryPanel::SetLaunchType(
     extensions::LaunchType launch_type) const {
   DCHECK(CanSetLaunchType());
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   extensions::SetLaunchType(service, app_->id(), launch_type);
 }
 
 bool AppInfoSummaryPanel::CanSetLaunchType() const {
   // V2 apps don't have a launch type, and neither does the Chrome app.
   return app_->id() != extension_misc::kChromeAppId && !app_->is_platform_app();
 }