Implemented upload progress indicator in status bar.

chrome/browser/tab_contents/tab_contents.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/tab_contents/tab_contents.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/file_version_info.h"
 #include "base/process_util.h"
@@ skipping 222 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(fav_icon_helper_(this)),
       select_file_dialog_(),
       pending_install_(),
       is_loading_(false),
       is_crashed_(false),
       waiting_for_response_(false),
       max_page_id_(-1),
       current_load_start_(),
       load_state_(net::LOAD_STATE_IDLE),
       load_state_host_(),
+      upload_size_(0),
+      upload_position_(0),
       received_page_title_(false),
       is_starred_(false),
       contents_mime_type_(),
       encoding_(),
       blocked_popups_(NULL),
       infobar_delegates_(),
       find_ui_active_(false),
       find_op_aborted_(false),
       current_find_request_id_(find_request_id_counter_++),
       find_text_(),
@@ skipping 296 matching lines @@
   switch (load_state_) {
     case net::LOAD_STATE_WAITING_FOR_CACHE:
       return l10n_util::GetString(IDS_LOAD_STATE_WAITING_FOR_CACHE);
     case net::LOAD_STATE_RESOLVING_PROXY_FOR_URL:
       return l10n_util::GetString(IDS_LOAD_STATE_RESOLVING_PROXY_FOR_URL);
     case net::LOAD_STATE_RESOLVING_HOST:
       return l10n_util::GetString(IDS_LOAD_STATE_RESOLVING_HOST);
     case net::LOAD_STATE_CONNECTING:
       return l10n_util::GetString(IDS_LOAD_STATE_CONNECTING);
     case net::LOAD_STATE_SENDING_REQUEST:
-      return l10n_util::GetString(IDS_LOAD_STATE_SENDING_REQUEST);
+      if (upload_size_)
+        return l10n_util::GetStringF(
+                    IDS_LOAD_STATE_SENDING_REQUEST_WITH_PROGRESS,
+                    static_cast<int>((100 * upload_position_) / upload_size_));
+      else
+        return l10n_util::GetString(IDS_LOAD_STATE_SENDING_REQUEST);
     case net::LOAD_STATE_WAITING_FOR_RESPONSE:
       return l10n_util::GetStringF(IDS_LOAD_STATE_WAITING_FOR_RESPONSE,
                                    load_state_host_);
     // Ignore net::LOAD_STATE_READING_RESPONSE and net::LOAD_STATE_IDLE
     case net::LOAD_STATE_IDLE:
     case net::LOAD_STATE_READING_RESPONSE:
       break;
   }
 
   return std::wstring();
@@ skipping 587 matching lines @@
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading and calls the base implementation.
 void TabContents::SetIsLoading(bool is_loading,
                                LoadNotificationDetails* details) {
   if (is_loading == is_loading_)
     return;
 
   if (!is_loading) {
     load_state_ = net::LOAD_STATE_IDLE;
     load_state_host_.clear();
+    upload_size_ = 0;
+    upload_position_ = 0;
   }
 
   render_manager_.SetIsLoading(is_loading);
 
   is_loading_ = is_loading;
   waiting_for_response_ = is_loading;
 
   if (delegate_)
     delegate_->LoadingStateChanged(this);
   NotifyNavigationStateChanged(INVALIDATE_LOAD);
@@ skipping 1202 matching lines @@
 
   if (render_view_host() && render_view_host()->IsRenderViewLive())
     HungRendererDialog::ShowForTabContents(this);
 }
 
 void TabContents::RendererResponsive(RenderViewHost* render_view_host) {
   HungRendererDialog::HideForTabContents(this);
 }
 
 void TabContents::LoadStateChanged(const GURL& url,
-                                   net::LoadState load_state) {
+                                   net::LoadState load_state,
+                                   uint64 upload_position,
+                                   uint64 upload_size) {
   load_state_ = load_state;
+  upload_position_ = upload_position;
+  upload_size_ = upload_size;
   std::wstring languages =
       profile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
   load_state_host_.clear();
   std::string host = url.host();
   net::IDNToUnicode(host.c_str(), host.size(), languages, &load_state_host_);
   if (load_state_ == net::LOAD_STATE_READING_RESPONSE)
     SetNotWaitingForResponse();
   if (is_loading())
     NotifyNavigationStateChanged(INVALIDATE_LOAD | INVALIDATE_TAB);
 }
@@ skipping 125 matching lines @@
 
     default:
       NOTREACHED();
   }
 }
 
 void TabContents::set_encoding(const std::string& encoding) {
   encoding_ = CharacterEncoding::GetCanonicalEncodingNameByAliasName(encoding);
 }