[Offline Pages] Expanding event logger to be used by harness.

chrome/android/javatests/src/org/chromium/chrome/browser/offlinepages/OfflinePageSavePageLaterEvaluationTest.java

 // Copyright 2016 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.
 
 package org.chromium.chrome.browser.offlinepages;
 
 import android.app.NotificationManager;
 import android.content.Context;
 import android.os.Environment;
 import android.text.TextUtils;
@@ skipping 78 matching lines @@
     private OfflinePageEvaluationBridge mBridge;
     private OfflinePageEvaluationObserver mObserver;
 
     private CountDownLatch mCompletionLatch;
     private List<String> mUrls;
     private int mCount;
     private boolean mIsUserRequested;
     private boolean mUseTestScheduler;
 
     private LongSparseArray<RequestMetadata> mRequestMetadata;
-    private OutputStreamWriter mLogOutput;
 
     public OfflinePageSavePageLaterEvaluationTest() {
         super(ChromeActivity.class);
     }
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mRequestMetadata = new LongSparseArray<RequestMetadata>();
         mCount = 0;
@@ skipping 21 matching lines @@
                             public void onResult(Integer removedCount) {
                                 mClearingSemaphore.release();
                             }
                         });
                     }
                 });
             }
         });
         checkTrue(mClearingSemaphore.tryAcquire(REMOVE_REQUESTS_TIMEOUT_MS, TimeUnit.MILLISECONDS),
                 "Timed out when clearing remaining requests!");
+        mBridge.closeLog();
         super.tearDown();
     }
 
     @Override
     public void startMainActivity() throws InterruptedException {
         startMainActivityOnBlankPage();
     }
 
     /**
      * Get a reader for a given input file path.
@@ skipping 20 matching lines @@
         File externalArchiveDir =
                 new File(Environment.getExternalStorageDirectory(), SAVED_PAGES_EXTERNAL_PATH);
         try {
             // Clear the old archive folder.
             if (externalArchiveDir.exists()) {
                 String[] files = externalArchiveDir.list();
                 if (files != null) {
                     for (String file : files) {
                         File currentFile = new File(externalArchiveDir.getPath(), file);
                         if (!currentFile.delete()) {
-                            logError(file + " cannot be deleted when clearing previous archives.");
+                            log(file + " cannot be deleted when clearing previous archives.");
                         }
                     }
                 }
-            } else if (!externalArchiveDir.mkdir()) {
-                logError("Cannot create directory on external storage to store saved pages.");
+            }
+            if (!externalArchiveDir.mkdir()) {
+                log("Cannot create directory on external storage to store saved pages.");
             }
         } catch (SecurityException e) {
-            logError("Failed to delete or create external archive folder!");
+            log("Failed to delete or create external archive folder!");
         }
         return externalArchiveDir;
     }
 
     /**
-     * Logs error in both console and output file.
+     * Print log message in output file through evaluation bridge.
      */
-    private void logError(String error) {
-        Log.e(TAG, error);
-        if (mLogOutput != null) {
-            try {
-                mLogOutput.write(error + NEW_LINE);
-                mLogOutput.flush();
-            } catch (Exception e) {
-                Log.e(TAG, e.getMessage(), e);
-            }
-        }
+    private void log(String message) {
+        mBridge.log(TAG, message);
     }
 
     /**
      * Assert the condition is true, otherwise abort the test and log.
      */
     private void checkTrue(boolean condition, String message) {
         if (!condition) {
-            logError(message);
-            if (mLogOutput != null) {
-                try {
-                    mLogOutput.close();
-                } catch (IOException e) {
-                    Log.e(TAG, e.getMessage(), e);
-                }
-            }
+            log(message);
             fail();
         }
     }
 
     /**
      * Initializes the evaluation bridge which will be used.
      * @param useCustomScheduler True if customized scheduler (the one with immediate scheduling)
      *                           will be used. False otherwise.
      */
     private void initializeBridgeForProfile(final boolean useTestingScheduler)
             throws InterruptedException {
         final Semaphore semaphore = new Semaphore(0);
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 Profile profile = Profile.getLastUsedProfile();
                 mBridge = OfflinePageEvaluationBridge.getForProfile(profile, useTestingScheduler);
                 if (mBridge == null) {
-                    logError("OfflinePageEvaluationBridge initialization failed!");
+                    fail("OfflinePageEvaluationBridge initialization failed!");
                     return;
                 }
                 if (mBridge.isOfflinePageModelLoaded()) {
                     semaphore.release();
                     return;
                 }
                 mBridge.addObserver(new OfflinePageEvaluationObserver() {
                     @Override
                     public void offlinePageModelLoaded() {
                         semaphore.release();
                         mBridge.removeObserver(this);
                     }
                 });
             }
         });
         checkTrue(semaphore.tryAcquire(PAGE_MODEL_LOAD_TIMEOUT_MS, TimeUnit.MILLISECONDS),
                 "Timed out when loading OfflinePageModel!");
     }
 
     /**
      * Set up the input/output, bridge and observer we're going to use.
      * @param useCustomScheduler True if customized scheduler (the one with immediate scheduling)
      *                           will be used. False otherwise.
      */
     protected void setUpIOAndBridge(final boolean useCustomScheduler) throws InterruptedException {
         try {
-            mLogOutput = getOutputStream(LOG_OUTPUT_FILE_PATH);
-        } catch (IOException e) {
-            Log.wtf(TAG, "Cannot set output file!");
-            Log.wtf(TAG, e.getMessage(), e);
-        }
-        try {
             getUrlListFromInputFile(INPUT_FILE_PATH);
         } catch (IOException e) {
-            Log.wtf(TAG, "Cannot read input file!");
-            Log.wtf(TAG, e.getMessage(), e);
+            Log.wtf(TAG, "Cannot read input file!", e);
         }
         checkTrue(mUrls != null, "URLs weren't loaded.");
         checkTrue(mUrls.size() > 0, "No valid URLs in the input file.");
 
         mCompletionLatch = new CountDownLatch(1);
 
         initializeBridgeForProfile(useCustomScheduler);
         mObserver = new OfflinePageEvaluationObserver() {
             public void savePageRequestAdded(SavePageRequest request) {
                 RequestMetadata metadata = new RequestMetadata();
@@ skipping 13 matching lines @@
                 }
                 metadata.mStatus = status;
                 if (mCount == mUrls.size()) {
                     mCompletionLatch.countDown();
                     return;
                 }
             }
             public void savePageRequestChanged(SavePageRequest request) {}
         };
         mBridge.addObserver(mObserver);
+        try {
+            File logOutputFile =
+                    new File(Environment.getExternalStorageDirectory(), LOG_OUTPUT_FILE_PATH);
+            mBridge.setLogOutputFile(logOutputFile);
+        } catch (IOException e) {
+            Log.wtf(TAG, "Cannot set log output file!", e);
+        }
     }
 
     /**
      * Calls SavePageLater on the bridge to try to offline an url.
      * @param url The url to be saved.
      * @param namespace The namespace this request belongs to.
      */
     private void savePageLater(final String url, final String namespace)
             throws InterruptedException {
         ThreadUtils.runOnUiThread(new Runnable() {
             @Override
             public void run() {
                 mBridge.savePageLater(url, namespace, mIsUserRequested);
             }
         });
     }
 
     private void processUrls(List<String> urls) throws InterruptedException, IOException {
         if (mBridge == null) {
-            logError("Test initialization error, aborting. No results would be written.");
+            fail("Test initialization error, aborting. No results would be written.");
             return;
         }
         for (String url : mUrls) {
             savePageLater(url, NAMESPACE);
         }
 
         mCompletionLatch.await();
         writeResults();
     }
 
@@ skipping 81 matching lines @@
      * https://www.google.com/;SUCCESS;110 KB;273805
      * At the end of the file there will be a summary:
      * Total requested URLs: XX, Completed: XX, Failed: XX, Failure Rate: XX.XX%
      */
     private void writeResults() throws IOException, InterruptedException {
         loadSavedPages();
         OutputStreamWriter output = getOutputStream(RESULT_OUTPUT_FILE_PATH);
         try {
             int failedCount = 0;
             if (mCount < mUrls.size()) {
-                logError("Test terminated before all requests completed.");
+                log("Test terminated before all requests completed.");
             }
             File externalArchiveDir = getExternalArchiveDir();
             for (int i = 0; i < mRequestMetadata.size(); i++) {
                 RequestMetadata metadata = mRequestMetadata.valueAt(i);
                 long requestId = metadata.mId;
                 int status = metadata.mStatus;
                 String url = metadata.mUrl;
                 OfflinePageItem page = metadata.mPage;
                 if (page == null) {
                     output.write(url + DELIMITER + statusToString(status) + NEW_LINE);
                     if (status != -1) {
                         failedCount++;
                     }
                     continue;
                 }
                 output.write(metadata.mUrl + DELIMITER + statusToString(status) + DELIMITER
                         + page.getFileSize() / 1000 + " KB" + DELIMITER
                         + metadata.mTimeDelta.getTimeDelta() + NEW_LINE);
                 // Move the page to external storage if external archive exists.
                 File originalPage = new File(page.getFilePath());
                 File externalPage = new File(externalArchiveDir, originalPage.getName());
                 if (!OfflinePageUtils.copyToShareableLocation(originalPage, externalPage)) {
-                    logError("Saved page for url " + page.getUrl() + " cannot be moved.");
+                    log("Saved page for url " + page.getUrl() + " cannot be moved.");
                 }
             }
             output.write(String.format(
                     "Total requested URLs: %d, Completed: %d, Failed: %d, Failure Rate: %.2f%%"
                             + NEW_LINE,
                     mUrls.size(), mCount, failedCount, (failedCount * 100.0 / mCount)));
         } catch (FileNotFoundException e) {
             Log.e(TAG, e.getMessage(), e);
         } finally {
             if (output != null) {
                 output.close();
             }
-            if (mLogOutput != null) {
-                mLogOutput.close();
-            }
         }
     }
 
     /**
      * Method to parse config files for test parameters.
      */
     public void parseConfigFile() throws IOException {
         Properties properties = new Properties();
         InputStream inputStream = null;
         try {
@@ skipping 17 matching lines @@
      * The test is the entry point for all kinds of testing of SavePageLater.
      * It is encouraged to use run_offline_page_evaluation_test.py to run this test.
      */
     @Manual
     public void testFailureRate() throws IOException, InterruptedException {
         parseConfigFile();
         setUpIOAndBridge(mUseTestScheduler);
         processUrls(mUrls);
     }
 }