chromeos: Clean up user code of OpenNewTab in file_manager_util.cc

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

 // Copyright (c) 2012 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/file_manager_util.h"
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
-#include "base/json/json_reader.h"
+#include "base/json/json_file_value_serializer.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
@@ skipping 213 matching lines @@
 
   result->SetString("transferState",
                     OperationTransferStateToString(status.transfer_state));
   result->SetString("transferType",
                     OperationTypeToString(status.operation_type));
   result->SetInteger("processed", static_cast<int>(status.progress_current));
   result->SetInteger("total", static_cast<int>(status.progress_total));
   return result.release();
 }
 
-void OpenNewTab(const GURL& url, Profile* profile) {
+void OpenNewTab(Profile* profile, const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Browser* browser = chrome::FindOrCreateTabbedBrowser(
       profile ? profile : ProfileManager::GetDefaultProfileOrOffTheRecord(),
       chrome::HOST_DESKTOP_TYPE_ASH);
   chrome::AddSelectedTabWithURL(browser, url, content::PAGE_TRANSITION_LINK);
   // If the current browser is not tabbed then the new tab will be created
   // in a different browser. Make sure it is visible.
   browser->window()->Show();
 }
 
@@ skipping 238 matching lines @@
       OpenFileBrowserImpl(path, REUSE_SAME_PATH, "");
       return true;
     }
     return ExecuteBuiltinHandler(browser, path, action_id);
   }
 
   ExecuteHandler(profile, extension_id, action_id, url);
   return true;
 }
 
-// Reads an entire file into a string. Fails is the file is 4K or longer.
-bool ReadSmallFileToString(const base::FilePath& path, std::string* contents) {
-  FILE* file = file_util::OpenFile(path, "rb");
-  if (!file) {
-    return false;
+// Reads JSON from a Google Docs file and extracts a document url. When the file
+// is not in GDoc format, returns a file URL for |file_path| as fallback.
+GURL ReadUrlFromGDocOnBlockingPool(const base::FilePath& file_path) {
+  const int64 kMaxGDocSize = 4096;
+  int64 file_size = 0;
+  if (!file_util::GetFileSize(file_path, &file_size) ||
+      file_size > kMaxGDocSize) {
+    DLOG(INFO) << "File too large to be a GDoc file " << file_path.value();
+    return net::FilePathToFileURL(file_path);
   }
 
-  char buf[1 << 12];  // 4K
-  size_t len = fread(buf, 1, sizeof(buf), file);
-  if (len > 0) {
-    contents->append(buf, len);
-  }
-  file_util::CloseFile(file);
-
-  return len < sizeof(buf);
-}
-
-// Reads JSON from a Google Docs file, extracts a document url and opens it
-// in a tab.
-void ReadUrlFromGDocOnBlockingPool(const base::FilePath& file_path) {
-  std::string contents;
-  if (!ReadSmallFileToString(file_path, &contents)) {
-    LOG(ERROR) << "Error reading " << file_path.value();
-    return;
+  JSONFileValueSerializer reader(file_path);
+  std::string error_message;
+  scoped_ptr<base::Value> root_value(reader.Deserialize(NULL, &error_message));
+  if (!root_value.get()) {
+    DLOG(INFO) << "Failed to parse " << file_path.value() << "as JSON."
+               << " error = " << error_message;
+    return net::FilePathToFileURL(file_path);
   }
 
-  scoped_ptr<base::Value> root_value;
-  root_value.reset(base::JSONReader::Read(contents));
-
-  DictionaryValue* dictionary_value;
+  base::DictionaryValue* dictionary_value = NULL;
   std::string edit_url_string;
-  if (!root_value.get() ||
-      !root_value->GetAsDictionary(&dictionary_value) ||
+  if (!root_value->GetAsDictionary(&dictionary_value) ||
       !dictionary_value->GetString("url", &edit_url_string)) {
-    LOG(ERROR) << "Invalid JSON in " << file_path.value();
-    return;
+    DLOG(INFO) << "Non GDoc JSON in " << file_path.value();
+    return net::FilePathToFileURL(file_path);
   }
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      base::Bind(OpenNewTab, GURL(edit_url_string), (Profile*)NULL));
+  return GURL(edit_url_string);
 }
 
 // Used to implement ViewItem().
 void ContinueViewItem(Profile* profile,
                       const base::FilePath& path,
                       base::PlatformFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == base::PLATFORM_FILE_OK) {
     // A directory exists at |path|. Open it with FileBrowser.
@@ skipping 307 matching lines @@
   // For things supported natively by the browser, we should open it
   // in a tab.
   if (IsSupportedBrowserExtension(file_extension.data()) ||
       ShouldBeOpenedWithPlugin(profile, file_extension.data())) {
     GURL page_url = net::FilePathToFileURL(path);
     // Override drive resource to point to internal handler instead of file URL.
     if (drive::util::IsUnderDriveMountPoint(path)) {
       page_url = drive::util::FilePathToDriveURL(
           drive::util::ExtractDrivePath(path));
     }
-    OpenNewTab(page_url, NULL);
+    OpenNewTab(profile, page_url);
     return true;
   }
 
   if (IsSupportedGDocsExtension(file_extension.data())) {
     if (drive::util::IsUnderDriveMountPoint(path)) {
       // The file is on Google Docs. Open with drive URL.
       GURL url = drive::util::FilePathToDriveURL(
           drive::util::ExtractDrivePath(path));
-      OpenNewTab(url, NULL);
+      OpenNewTab(profile, url);
     } else {
       // The file is local (downloaded from an attachment or otherwise copied).
       // Parse the file to extract the Docs url and open this url.
-      BrowserThread::PostBlockingPoolTask(
-          FROM_HERE, base::Bind(&ReadUrlFromGDocOnBlockingPool, path));
+      base::PostTaskAndReplyWithResult(
+          BrowserThread::GetBlockingPool(),
+          FROM_HERE,
+          base::Bind(&ReadUrlFromGDocOnBlockingPool, path),
+          base::Bind(&OpenNewTab, static_cast<Profile*>(NULL)));
     }
     return true;
   }
 
   if (!IsFileManagerPackaged()) {
     if (internal_task_id == kFileBrowserPlayTaskId) {
       GURL url;
       if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
         return false;
       MediaPlayer* mediaplayer = MediaPlayer::GetInstance();
@@ skipping 67 matching lines @@
   for (google_apis::OperationProgressStatusList::const_iterator iter =
            list.begin();
        iter != list.end(); ++iter) {
     result_list->Append(
         ProgessStatusToDictionaryValue(profile, extension_id, *iter));
   }
   return result_list.release();
 }
 
 }  // namespace file_manager_util