Simplify fileBrowserPrivate.getDriveConnectionStatus().

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

 // Copyright 2013 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/extensions/file_manager/private_api_drive.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
@@ skipping 10 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "webkit/common/fileapi/file_system_info.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 namespace {
 
 // List of connection types of drive.
-// Keep this in sync with the DriveConnectionType in volume_manager.js.
+// Keep this in sync with the DriveConnectionType in common/js/util.js.
 const char kDriveConnectionTypeOffline[] = "offline";
 const char kDriveConnectionTypeMetered[] = "metered";
 const char kDriveConnectionTypeOnline[] = "online";
 
 // List of reasons of kDriveConnectionType*.
-// Keep this in sync with the DriveConnectionReason in volume_manager.js.
+// Keep this in sync with the DriveConnectionReason in common/js/util.js.
 const char kDriveConnectionReasonNotReady[] = "not_ready";
 const char kDriveConnectionReasonNoNetwork[] = "no_network";
 const char kDriveConnectionReasonNoService[] = "no_service";
 
 // Copies properties from |entry_proto| to |properties|.
 void FillDriveEntryPropertiesValue(
     const drive::ResourceEntry& entry_proto,
     api::file_browser_private::DriveEntryProperties* properties) {
   properties->shared_with_me.reset(new bool(entry_proto.shared_with_me()));
 
@@ skipping 455 matching lines @@
     result_dict->SetString("highlightedBaseName",
                            results->at(i).highlighted_base_name);
     results_list->Append(result_dict);
   }
 
   SetResult(results_list);
   SendResponse(true);
 }
 
 bool FileBrowserPrivateGetDriveConnectionStateFunction::RunImpl() {
-  drive::DriveServiceInterface* const drive_service =
-      drive::util::GetDriveServiceByProfile(GetProfile());
-
   api::file_browser_private::GetDriveConnectionState::Results::Result result;
 
-  const bool ready = drive_service && drive_service->CanSendRequest();
-  const bool is_connection_cellular =
-      net::NetworkChangeNotifier::IsConnectionCellular(
-          net::NetworkChangeNotifier::GetConnectionType());
-
-  if (net::NetworkChangeNotifier::IsOffline() || !ready) {
-    result.type = kDriveConnectionTypeOffline;
-    if (net::NetworkChangeNotifier::IsOffline())
-      result.reasons.push_back(kDriveConnectionReasonNoNetwork);
-    if (!ready)
-      result.reasons.push_back(kDriveConnectionReasonNotReady);
-    if (!drive_service)
-      result.reasons.push_back(kDriveConnectionReasonNoService);
-  } else if (
-      is_connection_cellular &&
-      GetProfile()->GetPrefs()->GetBoolean(
-        prefs::kDisableDriveOverCellular)) {
-    result.type = kDriveConnectionTypeMetered;
-  } else {
-    result.type = kDriveConnectionTypeOnline;
+  switch (drive::util::GetDriveConnectionStatus(GetProfile())) {
+    case drive::util::DRIVE_DISCONNECTED_NOSERVICE:
+      result.type = kDriveConnectionTypeOffline;
+      result.reason.reset(new std::string(kDriveConnectionReasonNoService));
+      break;
+    case drive::util::DRIVE_DISCONNECTED_NONETWORK:
+      result.type = kDriveConnectionTypeOffline;
+      result.reason.reset(new std::string(kDriveConnectionReasonNoNetwork));
+      break;
+    case drive::util::DRIVE_DISCONNECTED_NOTREADY:
+      result.type = kDriveConnectionTypeOffline;
+      result.reason.reset(new std::string(kDriveConnectionReasonNotReady));
+      break;
+    case drive::util::DRIVE_CONNECTED_METERED:
+      result.type = kDriveConnectionTypeMetered;
+      break;
+    case drive::util::DRIVE_CONNECTED:
+      result.type = kDriveConnectionTypeOnline;
+      break;
   }
 
   results_ = api::file_browser_private::GetDriveConnectionState::Results::
       Create(result);
 
   drive::util::Log(logging::LOG_INFO, "%s succeeded.", name().c_str());
   return true;
 }
 
 bool FileBrowserPrivateRequestAccessTokenFunction::RunImpl() {
@@ skipping 62 matching lines @@
     error_ = "Share Url for this item is not available.";
     SendResponse(false);
     return;
   }
 
   SetResult(new base::StringValue(share_url.spec()));
   SendResponse(true);
 }
 
 }  // namespace extensions